{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "目录\n",
    "🔍 特征理解\n",
    "\n",
    "🔋 特征增强\n",
    "\n",
    "🔨 特征构建\n",
    "\n",
    "✅ 特征选择\n",
    "\n",
    "💫 特征转换\n",
    "\n",
    "📖 特征学习\n",
    "\n",
    "作者：城东\n",
    "链接：https://www.zhihu.com/question/28641663/answer/110165221\n",
    "来源：知乎\n",
    "著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。\n",
    "\n",
    "## 什么是特征\n",
    "\n",
    "<div align=center>\n",
    "<img width=\"700\" src=\"imgs/toc.jpg\"/>\n",
    "</div>\n",
    "<div align=center>目录</div>\n",
    "特征工程是什么？　　有这么一句话在业界广泛流传：数据和特征决定了机器学习的上限，而模型和算法只是逼近这个上限而已。那特征工程到底是什么呢？顾名思义，其本质是一项工程活动，目的是最大限度地从原始数据中提取特征以供算法和模型使用。通过总结和归纳，人们认为特征工程包括以下方面：\n",
    "<div align=center>\n",
    "<img width=\"700\" src=\"https://pic2.zhimg.com/80/20e4522e6104ad71fc543cc21f402b36_hd.jpg\"/>\n",
    "</div>\n",
    "<div align=center> </div>\n",
    "\n",
    "5 总结　　再让我们回归一下本文开始的特征工程的思维导图，我们可以使用sklearn完成几乎所有特征处理的工作，而且不管是数据预处理，还是特征选择，抑或降维，它们都是通过某个类的方法fit_transform完成的，fit_transform要不只带一个参数：特征矩阵，要不带两个参数：特征矩阵加目标向量。这些难道都是巧合吗？还是故意设计成这样？方法fit_transform中有fit这一单词，它和训练模型的fit方法有关联吗？接下来，我将在《使用sklearn优雅地进行数据挖掘》中阐述其中的奥妙！6 参考资料FAQ: What is dummy coding?IRIS（鸢尾花）数据集卡方检验干货：结合Scikit-learn介绍几种常用的特征选择方法机器学习中，有哪些特征选择的工程方法？机器学习中的数学(4)-线性判别分析（LDA）, 主成分分析(PCA)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "1. 结构化数据和非结构化数据\n",
    " > 例如可以用规则化网格、表格表示的数据： 图像，声音； 非结构化数据，例如文本，网络，图等。\n",
    " \n",
    "2. 定量和定性数据\n",
    "  > 定量数据：指的是一些数值，用于衡量某件东西的数量；\n",
    "  \n",
    ">定性数据：指的是一些类别，用于描述某件东西的性质。\n",
    "\n",
    "除了定量和定性，还可以细分为定类（nominal）、定序（ordinal）、定距（interval）、定比数据（ratio）\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1）定类（nominal）\n",
    "只有分类，比如：血型（A／B／O／AB型）、性别（男／女）、货币（人民币／美元／日元），而且值得注意的是这些分类之间没有大小可比性。一般画图的话就只能看下分布占比，可以用**条形图、饼图**来表示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWQAAADuCAYAAAAOR30qAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xt8lNWdx/HPLwkJ9zsoCAiCKEgFIRaLl1qsBSpeAC9lt6igIl5AkequuO68YqmriNYqdkFRa9l6L1gVW+tlrSAK6lqEIgKKiki4BETKPZnf/nEmMISEzExm5jwz83u/XvMieXieZ37JJN+cOc855xFVxRhjjH95vgswxhjjWCAbY0xAWCAbY0xAWCAbY0xAWCAbY0xAWCAbY0xAWCAbY0xAWCAbY0xAWCAbY0xAWCAbY0xAWCAbkyFEpJmI1Pddh0kdC2RjUkRE2ojImyJSKCJ5ItJCRP4gIvVFpGFke76ISDXHiojkV9l8NnBX1D5Xisj1kUfHKsdfLiKNRWSwiAxKzVdokk1scSFjUkNEHgeOB7oBS4C1QHfgRGA+cC/QH7gACFc5PA94VlWniUgrYC6wB6gPNAOmATcCtwDTgR+o6tbI8x4NzAGKgbbAy8Dpqro7ZV+sSQoLZGNSQETOBi4HngHGAY/gAvReYCRwv6ouiuN8o3FB/CjwNtAXeA24EHhKVYdE7fsi8JCqvhr5/AbgDOBnqrqvzl+cSZkC3wUYk41U9TURWQ10Au4EzgQWA1uAVUAvYBGAiBSp6p7o40WkUFX3Rj4+DhfGo4BjI8efG9l1KPBi1HETgW+Bv0bV8hsROQp4R0SuVNWP4/laPvzww7YFBQWzIjVbN2fNwsCy8vLyK/v167cxkRNYIBuTOucBlwA7cV0H9YCTgIbA/VH7LRaRqi3XMqCy73c78DEwKer//xn5933gMRH5PdAaGAisBJaJSGtgDVDZFz0daBTvF1FQUDDryCOP7NGmTZuteXl59pa6BuFwWDZt2tSztLR0Fu61j5sFsjGp0wW4SVXfE5ELgdaqOqPqTqra+3AnUdVvROQ64FSgHBe8/SP/96mIPAlcp6pTibScReRDoJuq3hHpU75PVZ9I8OvoZWFcu7y8PG3Tps220tLSXomewwLZmNT5BpgiIkXAacCKSDCDaym3UdWqF/Nq0hYYp6orROR1YB+AiPQFvodrUUe7ELg78nF73AXFROVZGMcm8n1KuFvHAtlkFRH64d6WlwMVwA5gM7BZlfI0l/MALgiHAr8Cvgaewo28mAZcLCKTgb01HF8ElKjq87j+ycdEZCcuzAX3i98e+Acwq/IgEZkAlEddNOxO3QI565SVleU3aNAg3LBhw0D9obFANsEkUoALmw6RRwtcH2xB1L/zOPQC1W+B71d/SrYRCWdgU+TxGbAC+ARYpUpSRiGISDfcmOEncRfjfga0wvXnnglcrarLgadjPOVu4FJVXS0if8R9D4pU9eWo5xTccLcy4OeRbSHc+OVLk/BlVT5Rv6SdC0D1w9p2+eabbwqGDx9+zFtvvbWqXr16umXLlvwrrrii09NPP/1FRUWF1KtXT+vXrx9zuL744otN58+f3/ixxx5bC3Dfffe13r17twBcfPHF33br1m3/z8EDDzzQ6rLLLtv62muvNRYRRowY8V0iX2YsbNib8UOkIa6l1wU4igPB2yHy+RHU/tZvNKq/O/i0LKKGQI5BOfA5LpxX4C6kLVDlqwTPl3Yi0khVdyTznEuWLPmid+/em6OeJO2BfOGFF3ZevXp1/S+//LKoR48eu9q3b7/3888/r//pp582KC4u3n7TTTdtOP/887fXdp7S0tL8oUOHdissLAzv2bMnb/v27fkTJkzY8Nvf/rbtnXfe+fXEiRM7LV68eEWbNm0qAFauXFk4bNiwrkuXLv1k3bp1BUOGDDl28eLFKw7Xsl6yZEnr3r17d47rexBhQ1hMeogci8goRB5C5P+AbcACYDauJXk9boJEMdAOPz+bBbi39+cD/wb8AfhShC9FmC3CWBGO91BXzJIdxkEwd+7cpnv37pWbb755/Yknnrhj3LhxG7/88suiSZMmrR84cOC3oVBofSxhDHDkkUdWjBo1avPgwYO3vf7666vy8/O59tpry5o3b15x2mmn7ezYsePeyjAGGDduXKc77rhjXV5eHh07diy/5JJLyoYNG3bMnj17DpldmQzWZWGST6QprpV6CvAD3IiAVl5rqptOuC6ASDcAm3Az7f4MvKhKQmNOTWyGDRv2XY8ePXZ/9tlnhZMnTy594403mvTt23dH69atK7p27bpnyZIlDc4444wdAAUF1UdaeXk5IsKyZcuKtm3blv/MM8+0WrVqVf0uXbrsfuqpp5oBPPvss83OOeecbyuPKSkpadusWbPyYcOG7e+iuP322zeOGzeusLi4+PhZs2Z90b9//13J/FotkE1yiLQBRgAXAT/kwNjXbNQGGB55zBThPdzU5udU+dJrZVnqueeeaz5nzpyWDRo0CG/evLmgvLxcli5d2nDXrl1511133YZbb7213fTp048sKCiotiuhvLxcpkyZsnbEiBHb+vTps6tv375fV/5f06ZNKwBOPfXUHaNHj+5yzTXXlJWWlhb87W9/a9q1a9fd3bt3P2Hr1q0FHTp02FNRUSEAV1999cbt27cn/V2cBbJJnJt4MBy4GHehKptDuCZ5wIDIY2qkD/sZ4ClVNnitLIusWbOmaNq0aWvPOuusHY8//niLTZs2Fdxyyy2bove555571sdyrnvvvbftokWLGhcUFOiWLVsKPvroo08Aevfuveeiiy4qmzp1apspU6ZsePPNN1cDzJgxY+fq1auLpk2btn7lypWF48eP7zh+/PiqwwyTwvqQTXxEWiJyJSJ/BdYDM4GzyM0wrkpw3TS/BtaK8LQIZ3iuKSu0b99+7+23335Uv379jhszZswxM2bMaDtgwIDuAwYM6N68efM+FRUVtZ8kYtOmTQUzZ878cuHChStbtmxZXlhYqAALFixouHTp0gbbtm07qKE6Z86cFj/96U+/A/jqq6/qHXXUUTUNU6wzayGb2onk4WaAjQN+jP3cxKIebtr0JSIsA/4bmK1KTBefAi2GURHJNnny5I0dO3bcN2/evGannnrq+g4dOuy74oortixZsqT+zTff3CE/P/b2QF5eHmPGjOncoEGD8PLlyxuqKuFwmLVr19Y74YQTdt9www37W95TpkxpW1BQoAMHDtwB8Mknn9Tv2LFjygLZWsimZiJNcCuFrQReAAZjYZyIXsBDwDoRfivCcb4LyiTLli0rGj58eJf69euH586du6Znz5679+3bJ+Xl5bzxxhtNHn744bj67YuKisKzZ89es3DhwpX9+/ffvnfvXtm7d2/eyJEjt912220bGzdurOFwmLPPPrvr0qVLG8yZM2cNwKRJk9r97ne/a33JJZdsTc1XauOQTXVE2gM3AVfiVhkLqmSPQ06XCtyMvRJVVvsupjaHjEPOEd99911e06ZNY53avp+NQzbJIdIZkRm4yRGTCHYYZ7J83BC6T0R4TIQuvgsyh0okjOvKAtlUTtp4ArfO7tW4NRRM6hUAo4FPRZgpQsfaDjDZzQI5l4k0QuRu3OI0l2L9w77UA8YCq0W4WyT+NYtNdrBAzlUiF+PWa7gFFwjGv0Lc67FchAt8F2PSzwI514gcj1tP9xncQj4meDoBc0V4SYTOvovJRmVlZfk7d+5MyXoUdWFvUXOFSCPgP4GJWIs4UwwFBoowBZiWrKVB60pKkrvam4Zs+c1K1kLOBdY9kcka4m6S+ncRTvJdjC8TJkzosHv37rx27dqdePrpp3e/5pprOn799ddFbdq06TN06NBjXn311ca//OUv2x555JEndurUqVf0o1WrVr1nz57dHNzym8XFxcc98sgjrZcsWdKwe/fuPadPn95q1qxZbXr27Ln7kUceadusWbP9oytWrlxZOHPmzLZNmjQJ9+/ff2coFDoqlS1rC+RsJtIGkVew7ols0BN4T4SbRXLr9zbW5Tdvv/32jaWlpR9/9dVXy6IfZWVlS0aNGvUtBH/5zZx6YXOKyGnAR8AQ36WYpCkEptLq08elRNr7LiZdhg0b9t3UqVPXNW/evGLy5Mmly5Yta1B1+c1Yz7VkyZL9y29OmDChQyLLb3bp0mVPcXHx8YsWLYr5eWNlfcjZxt3G5xZgCvb6ZqHwFi49+2xgiJTIpRrSv/iuKB1qW34z1vM0a9YsbMtvmvQQaQn8HjjHdykmRc67ajXN1lZODX9FSuS/gNs1FPPdqzNSLMtvxqJz5877bPlNk3oi/XFdFBbG2arT/Lfp+1j0Oh0CTAbmSIlk9WSS2pbfLC8//A3Fw+Ew+/a5gRO2/KZJLZGJwN3YCIrsVbBzJaN+UtOiSecDC6REztOQrk11KbEMU0u22pbf/NWvftV25syZR9R0x5B9+/bJHXfc8fVVV121NcjLb1ogZzJ35+bZuLt2mKylO7lyQD71dtc/zE59gMVSIhdoSBelq7J0WLZsWdEvfvGLo0aOHLll7ty5ax555JGWZWVlBdHLb/br1293KBSK6d6Glctv9urVa8+gQYO6Ri+/WblPOBxm0KBBXVu2bFkevfzmW2+91XT27NlrUvW12vKbmUqkGfAK7tZBuSpTl9+Mz2l3zufHt50e4967gdEa0qeT9fS2/GZ8bPnNXONuKPoWuR3GuaHF6nfjCGOA+sCTUiLjUlVSrrDlN03tRDoAb+PeoppslrdvHWNP7pnAkQL8t5TIxGSXZFLLAjmTiHQDFgDH+y7FpJpW8C/nltHg27rcJOA+KZHbklaSSTkL5Ewh0guYDxztuxSTBr2eWUC3V09MwpmmSIn8KgnnySq22ptJnMjJwF+Alr5LMWnQYPPfGf6v8fQb12aylEg9DektyTiZCMld7U1JympvBQUFmpeXR17ewe3McDhMOBymoOBA3AV1tTcL5KAT+SHwEtDEdykmHcJbubr4CPLCyX73erOUyGYN6dQknzctold769Gjx6727dvvrVztrbi4ePtNN9204d133200b968Fnl5eQcNHQuHwzJs2LAtd9xxx4bS0tL8oUOHdissLAzv2bMnr3v37j0nTJiwYdasWW3uvPPOrydOnNjpqquu2lJ5bOVqb9dff31Z//79dw4ZMuTYIUOGbG/YsGFKhqdZIAeZSF/gZaCx71JMmgwdt5LmX/ZP0dnvkhIp1ZD+PkXnT4no1d4efvjhNldcccXmBx988IhJkyatf/rpp1tOnDhx48CBA3ecf/752++6667Sw52rcrW3bdu25Y8fP37zgAEDjr/22mvLnnzyyVbxrPb24osvfl5UVJT0ULY+5KAS6QzMw8I4d3RY+DbFj6QqjMGNvnhUSuSnKXyOpItntbddu3Yd0i9c2RUBttqbSYRIK1yf8ZG+SzFpUrBzFZedlY4JLQXAc1IiAzNpRl+sq7316dOnR7169Q5quTZv3rx8wYIFq8BWezPxEqkPvAgc57sUky66izGnSS1To5OpITBPSuQUDenqND1nncS62tunn366/HDnsdXeTLwew2bg5ZZTp35A+4+6pflZW+FWiWuY5udNSG2rvVVUVNR+kghb7c3ERuRWYKTvMkwatfj8Pc7+92QOcYvH94BZwL/Ec1Asw9SSrbbV3h599NEW06ZNa1cZrlXt3btXbr311vWjR4+21d5MDETOxd3lw+QKKf+Gq072PetypJTI+xrSX3uuo0axrvY2duzYrbGcz1Z7M4cncgLwLjbWOF4BWe1tLdAxzmO0gn8Zuozur/RORUVxKgd+rCH9W3X/aau9xcdWe8tk7iLes1gYp8kGoLKHYB9wLnAqruu+JtXtdyswCFDgf+Mvo+fzCwISxuDeKT97mBunhsPhcOCmGadaImEc+T4lvEqcBbJ/U3C3eDcptxW4DNgR+fxBoB/wDvA8sL2G46rbbxPQF3fXrE7xldGgbAkXjjwtvoNSri01/1VatmnTpma5GMrxCIfDsmnTpmbAskTPYX3IPomcDtgSiWmTDzyDu+MRuCWl74p8fAbwAfCjao6rbj/FvdN/G7ghjhrC3zK2uA15FfnxVJ4mg6RExmlIZ0RvLC8vv7K0tHRWaWlpL6wRdzhhYFl5efmViZ7AAtkXkcbA77Af8DRqWuXzHcBRkY9b4rozqlPdfr1w3f4dcSH9MNCj9hLOuW4FLb44JZ6q02yalMhfNaSfV27o16/fRuA8jzXlDAsDf6YBx/guIrc1BnZFPv4nNXf9VbffRGAUbo7FcNws91oc9d58Tp4R5DAGaAQ8ISVi2eCBfdN9EBkEXO27DNMPt94/wBKgc5z7fYu7FltErddxCnat5vKBxQmXml6nATf5LiIXWSCnm0hz4FHfZRhwF/hCuD7g5UB/4E1gegz7rQR640bYPQj88DDPo7sZc7pSb1fSF6NJoSlSIumePZjzLJDTbzoHOiSNF29F/j0aeA03nO113EW/gcD1Vfavbr/uwIlAF+ATXEjXYMC9i2n/4bHJqj5NioDAThbJVjYxJJ1EhgFzfJeRRQIyMeQwmq9ZxI3HpHJJzVT7qYb0z76LyBXWQk4XkXrAPb7LMGkk5esZe3J332XU0f1SIvV8F5ErLJDTZyzQ1XcRJl00zM8u2EjDsha+K6mj7sCNvovIFRbI6SDSCLjddxkmjXrMmc9x84IyNbqubpcSaee7iFxggZweNwFH+C7CpEn9rR9z0SVBmxpdF01ww0xMilkgp5pIa+AXvssw6RLextX9WgV0anRdjJYSiXdJOxMnC+TUm8yhc3ZNthoyYTkt1mTjsMZC3M+ySSEL5FQS6QRc67sMkybtF8+n/0M/8F1GCo2xVnJqWSCn1h24AfYm2xXs+ozRZ2bK1OhEFeIWgjYpYoGcKu4uIKN8l2HSQXdz+Q8rMmxqdKKukBLp4LuIbGWBnDo3Y9/f3HDK/Yvp8H6mTwCJVSG28FDKWGCkgkgL4GLfZZg0aPblYgbfdIbvMtJsjJRII99FZCML5NS4FMiFt6+5TcrXM7Y4F1dEa4b7GTdJZoGcGrbWcdbTMJeM2ECjzS19V+LJdb4LyEYWyMnm7pMXw718TEY7/k/zOf7FPr7L8OgEKZFTfReRbSyQk89ax9mu/talXHSRhZFbMMskkQVyMom0Ai70XYZJJd3G2OIW5JfbDYLhIikRm4WaRBbIyXU5NhEkuw2+cTktP7dxuE4D4FzfRWQTC+Tksrdw2azdBws45YFsnhqdCBvemUQWyMkiciZuMW+TjfJ3f87oH/b1XUYADbJui+SxQE4eaylkLd3D6DP3Ubizoe9KAqgION93EdnCAjl5hvouwKRI/wcX0WHRcb7LCDBrjCSJBXIyiPQBbFnCbNR07WKG3JBrU6Pj9RMpkWa+i8gGFsjJcZ7vAkwKSHkpV/ezG9PWrhD4ke8isoEFcnLY0J+so2Euvng9jTa18l1JhjjLdwHZwAK5rtw98/r5LsMkWfeX5tNj7km+y8ggA30XkA0skOvuR4D4LsIkUdG3y7hkhE2Njk9PKZF2vovIdBbIdWdv1bKKbmNscXObGp0QayXXkQVy3VkgZ5OfTPoHrT6zqdGJsUCuIwvkuhA5GsjFBcqz05EfLWDArwf4LiOD2fDAOrJArpv+vgswSZK/Zw1jTreLeHXTVUqkie8iMpkFct2c4LsAkwy6h8vP3EvhDrtPXN0I0Nt3EZnMArluLJCzwckPLaLjezY1OjnsXUYdWCDXjQVypmu69n3OGW99n8mTy7e1qjML5ESJFGIX9DKbVGxgbHEX32VkGQvkOrBATtxxgI1VzVga5qJL1tF4Y2vflWSZXlIi9XwXkakskBNn3RWZ7NhX5tPzj7bgfPIVAp18F5GpLJAT18t3ASZBRdv+wc8usKnRqWOBnCAL5MRZCzkj6Xdc9f0mNjU6pSyQE2SBnDgL5Ez0k5uX0XqlBUZqHe27gExlgZwIkXzgGN9lmDgdseQdBtxrU6NTz/7gJcgCOTHNgHzfRZg45O9Zw5jTbBZZelggJ8gCOTF2/7CMonu57KzdFP2zse9KcoStlpcgC+TENPddgIlD8Yx36fROD99l5BBrsCTIAjkx9gOXKZqs+4BzrrOp0ellK74lyAI5MRbImUAqNnJ1v6MRtVtspVdjKRH7nifAAjkxFsiBp8qIkWtpvKGN70pykAC2lGkCLJATY4EcdN3+8ja9nrO7gftjF1ATYIGcGAvkICv8bjkjz7fxxn5ZP3ICLJATY6Msgipv3w7Gfr8R+ftsxTG/6vsuIBNZICfGWshB9fMhm2j9qU3d9W+f7wIykQVyYuwKcjAceuHomDc+91CHOZQFcgIskBOz3XcBBoCfVrPtj2mvwlTHAjkBFsiJsUAOhh8jclD3kYb0A+ALP+WYKHt9F5CJLJAT80/fBRjA3Z1iaDXb56S7EHMIayEnwAI5MdZCDo4R1Wyzbgv/LJATYIGcGGshB8dgRKpe3HsX+MZHMXWyE/gM2JHEc+4BdifxfLEJk9yvImdYICcmK1rIYTIxtQ7RgCoX9zSkCsz1U06CdgFPAuuAJ3Bxdh/weOSx4TDH/i/wMDAv8vkK4CFgG7AKH/dG36whrUj7s2YBC+TEpDWQy3Erfp8ZeSwF+kR9/tphjn0EOAkYiXsP+T5wfOTf1/Dxu5oSmd9tsQEYBJwBdAU+Ar4HjI48jqjhuG+Ar4CrcIMAPwNWAz8G1gIV+HiRN6b9GbNElvw+pl1auyw+xgXq3ZHPy3Ch+nQtx32Daygtiuz7BLAFmIZrVLUD2qagXg/OQaQ+qtFvzt8GNgGZsbhQ58i/X+BayT2BlcAaXBgPpfp71HwB9MCNjO+KC2PB/RX/CvBzb+3DtefNYVgLOTFpbSG/B7wMfB+4AngHWAwMAC44TDHvAT8BinCNr/m4F3wX8DnQPaVVp1Vj3Je6X+Qt8wt+ykmQAv/AdcK0Ay4FxuJauatqOGYf0DTycQNcU+EE3F/hFsCruL/o6WUt5ARZICdmWzqf7GTgdVwI78M1il4FFgIn4roYq7MDOCrycUtcs2Uo8GugFfAUcE+qik6/C6vZllndFgKcg2sRb+fA8jztcW9tqlPIgfEMe3Gh3hnXidMUF8prUlPuYVgLOUEWyIlZj7t+nRYn4hpMAMW4Fm63qM9rajw1juwLruEUxnV1vA70w/3Or0hBvZ6ci0jVBYXeBL71UUzcFgB/j3y8G/eWqBT3oq2g5j7kdriuCXAxWLns1Re4Cw9+fsMtkBNkgZwI1TBpbHeMApbg3rm+gOsPfinyf88DNd1KuR/u95zI8Z0jH/8ZGIxrkGXRohzNgbOiN2hI9wEv+iknTv1wXQuP4UJ4NG56ywygI65/eCfwpyrHdcIF959xL/b3IsfXw/1FXkvNYZ463tYTEZFmIpKxK81lTSB7eCFWp+uJ/hMXyn2AHwCvAL8CeuH6hy+L7De8ynGdcGsgXgVMwP2Og3tX2xDXem6ZysLTL3NHWzTA9RmPwfUrHQFcG3lU/plpCJxf5bi8yHGdgH/FdVHk4S4KCnA5cEpqS6/Gylh3FJE2IvKmiBSKSJ6ItBCRP4hIfRFpKCKFcT732cBdUee/UkSujzw6Vnnuy0WksYgMFpFBcT5PSoiq+nlikTbAM7jGWjluScvpuOtWeUC5qsY8H15ELgROU9UbI59fyYE1Wf+kqmuj9r0c17g8DVBVfTWBL+B+4Ia4j0uzCty73664AM9ym4Ej0QNjYKVEinCjLWzB9PRpoiGNaSSSiDyO60nrhnsjtxZ3vflE3HXoe3E/ur/g0G7CJsDVqvqCiLTCjT3fg/u9b4YbUHQjcAsuW36gqlsjz3s07j1IMW6w0cvA6XrwSJ2089lCnoprF6wD/oobBt8Z98vzPHB6LCcRkVYi8jZwNdBPRD4WkUtxbYsVwPVEDVOLvBDjcde8PgKmJNiyrqnrNlDycY2qHAhjgNa4kbz7aUj3cGDKhEm9r+MI47NxlyX/Czc0/iHgGNwIz5eBElV9Q1V/o6odVbVblccRqvoCgKqW4a5vz8NNFKoAZuMuh34ArKkM44gHgcnqbAD+B/iDHHodIq28BHKsL0Qs5/L4QiyPc3+THpk/2iKzLYt1R1V9DfgP3KilO3ED9hbjfndXEUc7QkSOw7WKR+G6LFYB50b+eyhR1xJEZCLuYu9fo2r5DW5azTsicmKsz5tsXiaGqOprIrIa1/N1J27C2UEvhIh8ENm32imYIpKP6w49lgMvxLEk8EKIyFG4F+JKVY111ObSGPcz6TUMkes5uC/uz7gu8waeasolMQdyxHnAJbhLlm1xlyNPwvWY3x/HebbjLotOitpW2VJ/H3hMRH6Pexc1ENfPvUxEWuMu0FdOu5mOxztm+5ypV9sLMRm4VURq6kcuxPXhzsPHC6G6GZH1HBiRZoKhHW7OzDuVGzSkO6RE/gIM81ZV7lgS5/5dgJtU9b3IdaDWqjoj3idV1W9E5Drc3MRy3O97/8j/fSoiTwLXqepUIg02EfkQ6Kaqd0S6Mu9T1Sfife5k8hnIsbwQv4zlRB5fiKVYIAfRCKICOeKPWCCnw8I49/8Gdx2nCHeRfUUkD8A10NrW9C4ZQEQEyFfVclzDbpyqrhCR14lMmRGRvrgBgWVVDr+QAysStMddUPTKZyDX9kK0UTfeNxa+XoilVJmyawJhOHBTlW0v4eayxTuMysSuVEMa7xjkB3C/f0Nxozm/xk0iPR43SmKCiNxIzesrFwI340ZshXHviHfiMkRw18na4yalz6o8SEQm4EZyLYps6k6OB/JhX4g4whj8vRALObirxATD0YicjOr7lRs0pN9JibyGm5xsUiOu1rGIdMNdgHsSdw3oZ7hZ/fm460pXq+py3Gz/WOwGLlXV1SLyR1w3aJGqvhz1nIIb7lYG/DyyLYQbv3xpPPWngpdAjuWFiPOUvl6IN3GjOqpbh8v4NQJ3DSHaH7FATqWq3USHpaqrOXhUzJNRH99NnFT1hqiPKycJnVplHxWRn6vqjqhtJUBJvM+XCt4mhvggIo2iX4gknfQ9In3WJlBWo3ps9AYpkcoAWZwJAAAJYklEQVQ1lmzZ2dQ4RUP733maBGTN1OlYJD2Mnb/WvovxoBtVxpNqSLcAb/kpJ+vtAv7PdxGZLqcCOUUOd8MO41d1a1s8n/YqcsPfIos5mTqwQK67d8mSe+xloeoC+QXcRWCTXJmxql7AWSDXlRv/+JbvMky1TkDk+OgNGtINHFiV1CTPS7XvYmpjgZwc1o8cXJm7JGfm+EhD+rXvIrKBBXJyWD9ycFUXyHNw66CY5LDuiiSxQE4G1U85cCMdEywnIdIlekOkNbfYUz3ZyAI5SSyQk6fqzXVMcNhoi9T5UkNqw92SxAI5eR71XYCpka2RnDpeV0fLNhbIyaK6BLcgvgme7yPSIXqDhnQN7o4xJnGKuzmESRIL5OSaVfsuxgPh0HvAgrWS6+otDekXvovIJhbIyfUk7l59Jnhs+FvyWes4ySyQk0l1O/Cc7zJMtU5D5IjoDRrSFdi9ERP1HXZhNOkskJPPui2CKQ+4oJrtFiqJeVpDust3EdnGAjnZVN/BWl1BZaMtkkOJfdF4EwcL5NSwIXDBdCYiLaM3aEg/BlZ7qidTvRTp7jFJZoGcGr/H3b/NBEsBcH41262VHJ+pvgvIVhbIqaC6GRswH1Q22qJuFmpI47pVk4mdBXLq/BLY47sIc4izEWkavUFD+j62FkmsrHWcQhbIqaK6FpjhuwxziELg3Gq2Wyu5dp9gCwmllAVyat0J/NN3EeYQ1m2RmP/QUA7dFdkDC+RUUt0I/MZ3GeYQgxFpVGXbQmC9j2IyxEIN6RzfRWQ7C+TUmwZs9V2EOUgDYEj0hkjLb66fcjLCzb4LyAUWyKmm+i1wj+8yzCGs2yJ2czWkC30XkQsskNPjN8AG30WYg5yDSFGVbX8DNvsoJsDKgX/3XUSusEBOB9WduAt8JjiaAIOiN2hIK4AX/JQTWDM1pCt9F5ErLJDTZwbwme8izEGs2+Lw1gO3+S4il1ggp4vqXmCs7zLMQc5DpF6VbW8A3/ooJoCu15Bu811ELrFATifVN4HHfJdh9msODIzeoCHdB7zkp5xAmWvD3NLPAjn9fgGU+i7C7GfdFofaBlzvu4hcZIGcbqpbgfG+yzD7XYBIfpVtr5LbMyz/TUP6je8icpEFsg+qzwNP+y7DANAGOCN6g4Z0NzDPTznevQE87LuIXGWB7M+1wDrfRRjAui0qbQB+butV+GOB7Ivrurgcdzsc49cwRKTKtleAXLpnXBgXxnZ9wyMLZJ9UXwem+y7D0B74QfQGDekOXF9yrrhLQ/q67yJynQWyf7cAH/ouwuR0t8UC4D99F2EskP1T3Y27z5td1farukB+iey/N2IZMDIybdx4ZoEcBKrrgPPIrT7LoDkakeLoDZFZatn8Nn4fMFxD+rXvQoxjgRwUqh8Cl2EX+XzKtW6LazSkb/suwhxggRwkqs8BId9l5LDqAvlPuCUos800DemjvoswB7NADhrVXwJP+S4jRx2LyPeiN2hIy3DrJGeT53AXk03AWCAH0xhgke8ictSF1WzLpm6Ld4BRNvkjmCyQg8iNvLgAWOu7lBxUXbfFHNzEiUz3AXCOhnSP70JM9SyQg0q1FDgHu6VQup2AyHHRGzSkG3Aty0z2EfATW9842CyQg0x1KXAmtlxnumXbaIuPgbM1pHb384CzQA461X/gViOz7ov0qanbIhP7Xf8B/DhycdIEnAVyJlBdhQvlz32XkiP6ItIleoOGdC3wvqd6ErUcOEtDusl3ISY2FsiZQvULXCh/6rmSXJHp3RYLgNMi/d8mQ1ggZxI3xfoMYKnvUnJAdYH8fNqrSMwcrM84I1kgZxrVjbgLfbZCXGr1R+So6A0a0s+Bv3uqJ1bTgYsidz0xGcYCOROpbgHOAub7LiWLCTC8mu1B7bZQ3L3wxmtIs2HMdE6yQM5Uqttwofwb36VksUzpR96OaxVP9V2IqRtRm0GZ+UQuBh4FGvsuJcuEgXaRbqL9pESWAz38lHSIZcAIDelK34WYurMWcjZQfRY4GTfMySRPHjCsmu1BaSX/D9Dfwjh7WCBnC9UVwPeBp32XkmWCONpiL3CthnSUhnSn51pMElmXRTYSGQ/cC9TzXUoWKAeOiFxI3U9KZDXQ1UM9y4FLNaQ2yiYLWQs5G6k+iBuvbLfmqbsC3O21qkp3t0UFcBfQ18I4e1kgZyvV94A+uH5GUze+10j+BBigIb3Vls7MbhbI2Uy1DNVRwGDgC8/VZLKzEWlaZdv7pH7BpwrgbuAkDeniFD+XCQAL5Fyg+irQC7gP90tu4lMIDI3eELnjxpwUPuf/4ron/t1axbnDAjlXqO5AdRJQjM3wS0S6Rlt8DgzXkA7UkH6cgvObALNAzjWqf0f1DOBfgXW+y8kggxFpWGXbQpJ384DtwL8BPTWkc5N0TpNhLJBzleqTwHHAncAOz9VkgobAkOgNkTUj6hqeu4AHgWM1pFOteyK3WSDnMteNcRtwNFACbKnliFyXzNEW/wTuAbpoSCfYusUGbGKIiSbSGBgLTALae64miLYDbdADrVgpkQJgPdA6xnNsAx4A7teQ2h9AcxALZHMokULgUlyfZjfP1QTNeai+FL1BSmQWcEUtx30KzAQeszs/m5pYIJuaieTh3qbfiptkYuAJVC+P3iAlMgR4pZp99+KGxs3UkL6V+tJMprNANrER+RFuZMZwoIXnanzailvbYl/lBimRQmAj0CyyaSVuOdTH7QajJh4WyCY+rjtjEDASt8ZDI78FeTE4MtlmPymR/8LdteNZDWnQb/NkAsoC2STOjcs9DxfOg3Ez2rLdDuBmVP/bdyEm+1ggm+QQaY7rzhgODCC7ujW+AV4CXgTeiB5lYUwyWSCb5BMRoCdwauQxgMwZrRHGrTm8GLeA0HvAEuwXxaSBBbJJD5EjcMFcGdJ9CUYXxxpc8FYG8Ieo2sxF44UFsvHDXRzsgrvrRvSjE9AON9FC6vgsYWATbuJG9OMbKoNYdXMdn8OYpLFANsEkUg84EjdjsAWQj5vqX/lvXg3byjgQvBtQLU977cYkyALZGGMCwhYXMsaYgLBANsaYgLBANsaYgLBANsaYgLBANsaYgLBANsaYgLBANsaYgLBANsaYgLBANsaYgLBANsaYgLBANsaYgLBANsaYgLBANsaYgLBANsaYgLBANsaYgLBANsaYgLBANsaYgLBANsaYgLBANsaYgLBANsaYgPh/oT7SKbtlhwcAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "import numpy as np\n",
    "%matplotlib inline\n",
    "matplotlib.rcParams['font.sans-serif'] = ['SimHei']\n",
    "matplotlib.rcParams['axes.unicode_minus'] = False\n",
    "\n",
    "label_list = [\"第一部分\", \"第二部分\", \"第三部分\"]    # 各部分标签\n",
    "size = [55, 35, 10]    # 各部分大小\n",
    "color = [\"red\", \"green\", \"blue\"]     # 各部分颜色\n",
    "explode = [0.05, 0, 0]   # 各部分突出值\n",
    "\"\"\"\n",
    "绘制饼图\n",
    "explode：设置各部分突出\n",
    "label:设置各部分标签\n",
    "labeldistance:设置标签文本距圆心位置，1.1表示1.1倍半径\n",
    "autopct：设置圆里面文本\n",
    "shadow：设置是否有阴影\n",
    "startangle：起始角度，默认从0开始逆时针转\n",
    "pctdistance：设置圆内文本距圆心距离\n",
    "返回值\n",
    "l_text：圆内部文本，matplotlib.text.Text object\n",
    "p_text：圆外部文本\n",
    "\"\"\"\n",
    "patches, l_text, p_text = plt.pie(size, explode=explode, colors=color, labels=label_list, labeldistance=1.1, autopct=\"%1.1f%%\", shadow=False, startangle=90, pctdistance=0.6)\n",
    "plt.axis(\"equal\")    # 设置横轴和纵轴大小相等，这样饼才是圆的\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\matplotlib\\axes\\_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n",
      "  warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "# 设置matplotlib正常显示中文和负号\n",
    "matplotlib.rcParams['font.sans-serif']=['SimHei']   # 用黑体显示中文\n",
    "matplotlib.rcParams['axes.unicode_minus']=False     # 正常显示负号\n",
    "# 随机生成（10000,）服从正态分布的数据\n",
    "data = np.random.randn(10000)\n",
    "\"\"\"\n",
    "绘制直方图\n",
    "data:必选参数，绘图数据\n",
    "bins:直方图的长条形数目，可选项，默认为10\n",
    "normed:是否将得到的直方图向量归一化，可选项，默认为0，代表不归一化，显示频数。normed=1，表示归一化，显示频率。\n",
    "facecolor:长条形的颜色\n",
    "edgecolor:长条形边框的颜色\n",
    "alpha:透明度\n",
    "\"\"\"\n",
    "plt.hist(data, bins=40, normed=0, facecolor=\"blue\", edgecolor=\"black\", alpha=0.7)\n",
    "# 显示横轴标签\n",
    "plt.xlabel(\"区间\")\n",
    "# 显示纵轴标签\n",
    "plt.ylabel(\"频数/频率\")\n",
    "# 显示图标题\n",
    "plt.title(\"频数/频率分布直方图\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\matplotlib\\__init__.py:1855: MatplotlibDeprecationWarning: The *left* kwarg to `bar` is deprecated use *x* instead. Support for *left* will be removed in Matplotlib 3.0\n",
      "  return func(ax, *args, **kwargs)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "matplotlib.rcParams['font.sans-serif'] = ['SimHei']\n",
    "matplotlib.rcParams['axes.unicode_minus'] = False\n",
    "\n",
    "label_list = ['2014', '2015', '2016', '2017']\n",
    "num_list1 = [20, 30, 15, 35]\n",
    "num_list2 = [15, 30, 40, 20]\n",
    "x = range(len(num_list1))\n",
    "rects1 = plt.bar(left=x, height=num_list1, width=0.45, alpha=0.8, color='red', label=\"一部门\")\n",
    "rects2 = plt.bar(left=x, height=num_list2, width=0.45, color='green', label=\"二部门\", bottom=num_list1)\n",
    "plt.ylim(0, 80)\n",
    "plt.ylabel(\"数量\")\n",
    "plt.xticks(x, label_list)\n",
    "plt.xlabel(\"年份\")\n",
    "plt.title(\"某某公司\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "matplotlib.rcParams['font.sans-serif'] = ['SimHei']\n",
    "matplotlib.rcParams['axes.unicode_minus'] = False\n",
    "\n",
    "price = [39.5, 39.9, 45.4, 38.9, 33.34]\n",
    "\"\"\"\n",
    "绘制水平条形图方法barh\n",
    "参数一：y轴\n",
    "参数二：x轴\n",
    "\"\"\"\n",
    "plt.barh(range(5), price, height=0.7, color='steelblue', alpha=0.8)      # 从下往上画\n",
    "plt.yticks(range(5), ['亚马逊', '当当网', '中国图书网', '京东', '天猫'])\n",
    "plt.xlim(30,47)\n",
    "plt.xlabel(\"价格\")\n",
    "plt.title(\"不同平台图书价格\")\n",
    "for x, y in enumerate(price):\n",
    "    plt.text(y + 0.2, x - 0.1, '%s' % y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2）定序（ordinal）\n",
    "不仅有分类属性，而且其属性还可以进行一定的排序，例如成绩 ABCD， 胖瘦， 漫游的调查。\n",
    "可视化方面，和定类一样，不过就是多了一个 **箱体图** 可以用（因为定序变量可以有中位数）。\n",
    "\n",
    "![1234](\"/imgs/box-plot.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1fafd3615c0>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    " \n",
    "fig,axes = plt.subplots(2,1,figsize=(10,6))\n",
    "df = pd.DataFrame(np.random.rand(10,5),columns=['a','b','c','d','e'])\n",
    "color = dict(boxes='DarkGreen',whiskers='DarkOrange',medians='DarkBlue',caps='Gray')\n",
    " \n",
    "# 箱线图着色\n",
    "# whiskers：分位数与error bar横线之间竖线的颜色\n",
    "# medians：中位数线颜色\n",
    "# caps：error bar横线颜色\n",
    " \n",
    "df.plot.box(ylim = [0,1.2],\n",
    "           grid = True,\n",
    "           color = color,\n",
    "           ax = axes[0]\n",
    "           )\n",
    " \n",
    "df.plot.box(vert = False,\n",
    "           positions = [1,4,5,6,8],\n",
    "           ax = axes[1],\n",
    "           grid = True,\n",
    "           color = color)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3）定距（interval）\n",
    "定距的话，就是变量值之间可以做加减法计算，也就是可以引入均值、方差之类的名词了，而且能够画的图也多了，包括先前的那些，还包括了直方图。\n",
    "4）定比（ratio）\n",
    "定比相比于定距更加严格，不仅仅有定距的所有属性，同时，有一个 绝对零点 的概念，可以做加减乘除运算，比如说某个商品的价格是另一个的2倍。值得注意的是，温度一般不归入定比，而是定距，没有说20度是10度的两倍这种说法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<div align=center>\n",
    "<img width=\"700\" src=\"imgs/data_cls.webp\"/>\n",
    "</div>\n",
    "<div align=center>总结</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 4.0) # 设置figure_size尺寸\n",
    "plt.rcParams['image.interpolation'] = 'nearest' # 设置 interpolation style\n",
    "plt.rcParams['image.cmap'] = 'gray' # 设置 颜色 style\n",
    "plt.rcParams['savefig.dpi'] = 100 #图片像素\n",
    "plt.rcParams['figure.dpi'] = 100 #分辨率\n",
    "plt.rcParams['font.family'] = ['Arial Unicode MS'] #正常显示中文"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>SetID</th>\n",
       "      <th>Job Code</th>\n",
       "      <th>Eff Date</th>\n",
       "      <th>Sal End Date</th>\n",
       "      <th>Salary SetID</th>\n",
       "      <th>Sal Plan</th>\n",
       "      <th>Grade</th>\n",
       "      <th>Step</th>\n",
       "      <th>Biweekly High Rate</th>\n",
       "      <th>Biweekly Low Rate</th>\n",
       "      <th>Union Code</th>\n",
       "      <th>Extended Step</th>\n",
       "      <th>Pay Type</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>COMMN</td>\n",
       "      <td>0109</td>\n",
       "      <td>07/01/2009 12:00:00 AM</td>\n",
       "      <td>06/30/2010 12:00:00 AM</td>\n",
       "      <td>COMMN</td>\n",
       "      <td>SFM</td>\n",
       "      <td>00000</td>\n",
       "      <td>1</td>\n",
       "      <td>$0.00</td>\n",
       "      <td>$0.00</td>\n",
       "      <td>330</td>\n",
       "      <td>0</td>\n",
       "      <td>C</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>COMMN</td>\n",
       "      <td>0110</td>\n",
       "      <td>07/01/2009 12:00:00 AM</td>\n",
       "      <td>06/30/2010 12:00:00 AM</td>\n",
       "      <td>COMMN</td>\n",
       "      <td>SFM</td>\n",
       "      <td>00000</td>\n",
       "      <td>1</td>\n",
       "      <td>$15.00</td>\n",
       "      <td>$15.00</td>\n",
       "      <td>323</td>\n",
       "      <td>0</td>\n",
       "      <td>D</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>COMMN</td>\n",
       "      <td>0111</td>\n",
       "      <td>07/01/2009 12:00:00 AM</td>\n",
       "      <td>06/30/2010 12:00:00 AM</td>\n",
       "      <td>COMMN</td>\n",
       "      <td>SFM</td>\n",
       "      <td>00000</td>\n",
       "      <td>1</td>\n",
       "      <td>$25.00</td>\n",
       "      <td>$25.00</td>\n",
       "      <td>323</td>\n",
       "      <td>0</td>\n",
       "      <td>D</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>COMMN</td>\n",
       "      <td>0112</td>\n",
       "      <td>07/01/2009 12:00:00 AM</td>\n",
       "      <td>06/30/2010 12:00:00 AM</td>\n",
       "      <td>COMMN</td>\n",
       "      <td>SFM</td>\n",
       "      <td>00000</td>\n",
       "      <td>1</td>\n",
       "      <td>$50.00</td>\n",
       "      <td>$50.00</td>\n",
       "      <td>323</td>\n",
       "      <td>0</td>\n",
       "      <td>D</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>COMMN</td>\n",
       "      <td>0114</td>\n",
       "      <td>07/01/2009 12:00:00 AM</td>\n",
       "      <td>06/30/2010 12:00:00 AM</td>\n",
       "      <td>COMMN</td>\n",
       "      <td>SFM</td>\n",
       "      <td>00000</td>\n",
       "      <td>1</td>\n",
       "      <td>$100.00</td>\n",
       "      <td>$100.00</td>\n",
       "      <td>323</td>\n",
       "      <td>0</td>\n",
       "      <td>M</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   SetID Job Code                Eff Date            Sal End Date  \\\n",
       "0  COMMN     0109  07/01/2009 12:00:00 AM  06/30/2010 12:00:00 AM   \n",
       "1  COMMN     0110  07/01/2009 12:00:00 AM  06/30/2010 12:00:00 AM   \n",
       "2  COMMN     0111  07/01/2009 12:00:00 AM  06/30/2010 12:00:00 AM   \n",
       "3  COMMN     0112  07/01/2009 12:00:00 AM  06/30/2010 12:00:00 AM   \n",
       "4  COMMN     0114  07/01/2009 12:00:00 AM  06/30/2010 12:00:00 AM   \n",
       "\n",
       "  Salary SetID Sal Plan  Grade  Step Biweekly High Rate Biweekly Low Rate  \\\n",
       "0        COMMN      SFM  00000     1              $0.00             $0.00   \n",
       "1        COMMN      SFM  00000     1             $15.00            $15.00   \n",
       "2        COMMN      SFM  00000     1             $25.00            $25.00   \n",
       "3        COMMN      SFM  00000     1             $50.00            $50.00   \n",
       "4        COMMN      SFM  00000     1            $100.00           $100.00   \n",
       "\n",
       "   Union Code  Extended Step Pay Type  \n",
       "0         330              0        C  \n",
       "1         323              0        D  \n",
       "2         323              0        D  \n",
       "3         323              0        D  \n",
       "4         323              0        M  "
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#数据集 Salary_Ranges_by_Job_Classification\n",
    "salary_ranges = pd.read_csv('./data/Salary_Ranges_by_Job_Classification.csv')\n",
    "salary_ranges.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['SetID', 'Job Code', 'Eff Date', 'Sal End Date', 'Salary SetID',\n",
       "       'Sal Plan', 'Grade', 'Step', 'Biweekly High Rate', 'Biweekly Low Rate',\n",
       "       'Union Code', 'Extended Step', 'Pay Type'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "salary_ranges.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1fafc5099b0>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 绘制条形图\n",
    "salary_ranges['Grade'].value_counts().sort_values(ascending=False).head(10).plot(kind='bar')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1fa8ee74e80>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 绘制饼图\n",
    "salary_ranges['Biweekly High Rate'].value_counts().sort_values(ascending=False).head(10).plot(kind='pie')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1fa8eaa8d30>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 绘制箱体图\n",
    "salary_ranges['Union Code'].value_counts().sort_values(ascending=False).head(5).plot(kind='box')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1fa9ae9bfd0>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "salary_ranges['Biweekly High Rate'].value_counts().sort_values(ascending=False).head(60).hist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0           $0.00\n",
       "1          $15.00\n",
       "2          $25.00\n",
       "3          $50.00\n",
       "4         $100.00\n",
       "5         $100.00\n",
       "6         $200.00\n",
       "7         $500.00\n",
       "8           $0.00\n",
       "9       $10630.00\n",
       "10       $9175.00\n",
       "11       $4142.00\n",
       "12       $5242.00\n",
       "13       $3293.00\n",
       "14       $4496.00\n",
       "15       $4676.00\n",
       "16       $4762.00\n",
       "17      $11255.00\n",
       "18      $10376.00\n",
       "19       $9096.00\n",
       "20       $9456.00\n",
       "21       $9641.00\n",
       "22       $7392.00\n",
       "23       $7687.00\n",
       "24       $7835.00\n",
       "25       $3794.62\n",
       "26       $1326.00\n",
       "27       $1425.00\n",
       "28       $1532.00\n",
       "29       $1646.00\n",
       "          ...    \n",
       "1326     $4857.00\n",
       "1327     $4586.00\n",
       "1328     $4770.00\n",
       "1329     $4857.00\n",
       "1330     $5237.00\n",
       "1331     $5445.00\n",
       "1332     $5548.00\n",
       "1333     $6616.00\n",
       "1334     $6881.00\n",
       "1335     $7011.00\n",
       "1336     $6515.00\n",
       "1337     $2178.00\n",
       "1338     $2342.00\n",
       "1339     $2700.00\n",
       "1340     $2354.00\n",
       "1341     $3234.00\n",
       "1342     $1909.00\n",
       "1343     $2332.00\n",
       "1344     $2459.00\n",
       "1345     $2354.00\n",
       "1346     $3199.00\n",
       "1347     $3426.00\n",
       "1348     $3689.00\n",
       "1349     $1951.00\n",
       "1350     $2786.00\n",
       "1351     $2145.00\n",
       "1352     $3041.00\n",
       "1353     $3132.00\n",
       "1354     $3453.00\n",
       "1355     $3453.00\n",
       "Name: Biweekly High Rate, Length: 1356, dtype: object"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "salary_ranges['Biweekly High Rate']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 02 特征增强\n",
    "这一步其实就是数据清洗了，虽然上一步中也有涉及到部分清洗工作（比如清除空值、日期转换之类的），但却是分散的，这节重点讲讲数据清洗的一些技巧和实践代码，供大家在实际项目中去使用。\n",
    "Step1: 进行**EDA（Exploratory Data Analysis）**，思路如下：\n",
    "（1）首先看看目标占比情况（针对二分类问题，也就是0和1的占比情况），直接 value_counts()就可以解决，看看样本是否失衡。\n",
    "（2）接着看看有没有空值，直接统计 isnull().sum() 的个数，不过需要注意的是，可能统计出来没有缺失，并不是因为真的没有缺失，而且缺失被人用某个特殊值填充了，一般会用 -9、blank、unknown、0之类的，需要注意⚠️识别，后面需要对缺失进行合理填充。\n",
    "（2.1）怎么识别缺失值呢？一般可以通过 data.describe() 获取基本的描述性统计，根据均值、标准差、极大极小值等指标，结合变量含义来判断。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>times_pregment</th>\n",
       "      <th>plasma_glucose_concentration</th>\n",
       "      <th>diastolic_blood_pressure</th>\n",
       "      <th>triceps_thickness</th>\n",
       "      <th>serum_insulin</th>\n",
       "      <th>bmi</th>\n",
       "      <th>pedigree_function</th>\n",
       "      <th>age</th>\n",
       "      <th>onset_disbetes</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>6</td>\n",
       "      <td>148</td>\n",
       "      <td>72</td>\n",
       "      <td>35</td>\n",
       "      <td>0</td>\n",
       "      <td>33.6</td>\n",
       "      <td>0.627</td>\n",
       "      <td>50</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>85</td>\n",
       "      <td>66</td>\n",
       "      <td>29</td>\n",
       "      <td>0</td>\n",
       "      <td>26.6</td>\n",
       "      <td>0.351</td>\n",
       "      <td>31</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>8</td>\n",
       "      <td>183</td>\n",
       "      <td>64</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>23.3</td>\n",
       "      <td>0.672</td>\n",
       "      <td>32</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>89</td>\n",
       "      <td>66</td>\n",
       "      <td>23</td>\n",
       "      <td>94</td>\n",
       "      <td>28.1</td>\n",
       "      <td>0.167</td>\n",
       "      <td>21</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>137</td>\n",
       "      <td>40</td>\n",
       "      <td>35</td>\n",
       "      <td>168</td>\n",
       "      <td>43.1</td>\n",
       "      <td>2.288</td>\n",
       "      <td>33</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   times_pregment  plasma_glucose_concentration  diastolic_blood_pressure  \\\n",
       "0               6                           148                        72   \n",
       "1               1                            85                        66   \n",
       "2               8                           183                        64   \n",
       "3               1                            89                        66   \n",
       "4               0                           137                        40   \n",
       "\n",
       "   triceps_thickness  serum_insulin   bmi  pedigree_function  age  \\\n",
       "0                 35              0  33.6              0.627   50   \n",
       "1                 29              0  26.6              0.351   31   \n",
       "2                  0              0  23.3              0.672   32   \n",
       "3                 23             94  28.1              0.167   21   \n",
       "4                 35            168  43.1              2.288   33   \n",
       "\n",
       "   onset_disbetes  \n",
       "0               1  \n",
       "1               0  \n",
       "2               1  \n",
       "3               0  \n",
       "4               1  "
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 皮马印第安人糖尿病预测数据集\n",
    "pima_columns = ['times_pregment','plasma_glucose_concentration','diastolic_blood_pressure','triceps_thickness',\n",
    "                'serum_insulin','bmi','pedigree_function','age','onset_disbetes']\n",
    "pima = pd.read_csv('./data/pima.data', names=pima_columns)\n",
    "pima.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 768 entries, 0 to 767\n",
      "Data columns (total 9 columns):\n",
      "times_pregment                  768 non-null int64\n",
      "plasma_glucose_concentration    768 non-null int64\n",
      "diastolic_blood_pressure        768 non-null int64\n",
      "triceps_thickness               768 non-null int64\n",
      "serum_insulin                   768 non-null int64\n",
      "bmi                             768 non-null float64\n",
      "pedigree_function               768 non-null float64\n",
      "age                             768 non-null int64\n",
      "onset_disbetes                  768 non-null int64\n",
      "dtypes: float64(2), int64(7)\n",
      "memory usage: 54.1 KB\n"
     ]
    }
   ],
   "source": [
    "pima.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>times_pregment</th>\n",
       "      <th>plasma_glucose_concentration</th>\n",
       "      <th>diastolic_blood_pressure</th>\n",
       "      <th>triceps_thickness</th>\n",
       "      <th>serum_insulin</th>\n",
       "      <th>bmi</th>\n",
       "      <th>pedigree_function</th>\n",
       "      <th>age</th>\n",
       "      <th>onset_disbetes</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>768.000000</td>\n",
       "      <td>768.000000</td>\n",
       "      <td>768.000000</td>\n",
       "      <td>768.000000</td>\n",
       "      <td>768.000000</td>\n",
       "      <td>768.000000</td>\n",
       "      <td>768.000000</td>\n",
       "      <td>768.000000</td>\n",
       "      <td>768.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>3.845052</td>\n",
       "      <td>120.894531</td>\n",
       "      <td>69.105469</td>\n",
       "      <td>20.536458</td>\n",
       "      <td>79.799479</td>\n",
       "      <td>31.992578</td>\n",
       "      <td>0.471876</td>\n",
       "      <td>33.240885</td>\n",
       "      <td>0.348958</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>3.369578</td>\n",
       "      <td>31.972618</td>\n",
       "      <td>19.355807</td>\n",
       "      <td>15.952218</td>\n",
       "      <td>115.244002</td>\n",
       "      <td>7.884160</td>\n",
       "      <td>0.331329</td>\n",
       "      <td>11.760232</td>\n",
       "      <td>0.476951</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.078000</td>\n",
       "      <td>21.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>99.000000</td>\n",
       "      <td>62.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>27.300000</td>\n",
       "      <td>0.243750</td>\n",
       "      <td>24.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>3.000000</td>\n",
       "      <td>117.000000</td>\n",
       "      <td>72.000000</td>\n",
       "      <td>23.000000</td>\n",
       "      <td>30.500000</td>\n",
       "      <td>32.000000</td>\n",
       "      <td>0.372500</td>\n",
       "      <td>29.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>6.000000</td>\n",
       "      <td>140.250000</td>\n",
       "      <td>80.000000</td>\n",
       "      <td>32.000000</td>\n",
       "      <td>127.250000</td>\n",
       "      <td>36.600000</td>\n",
       "      <td>0.626250</td>\n",
       "      <td>41.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>17.000000</td>\n",
       "      <td>199.000000</td>\n",
       "      <td>122.000000</td>\n",
       "      <td>99.000000</td>\n",
       "      <td>846.000000</td>\n",
       "      <td>67.100000</td>\n",
       "      <td>2.420000</td>\n",
       "      <td>81.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       times_pregment  plasma_glucose_concentration  diastolic_blood_pressure  \\\n",
       "count      768.000000                    768.000000                768.000000   \n",
       "mean         3.845052                    120.894531                 69.105469   \n",
       "std          3.369578                     31.972618                 19.355807   \n",
       "min          0.000000                      0.000000                  0.000000   \n",
       "25%          1.000000                     99.000000                 62.000000   \n",
       "50%          3.000000                    117.000000                 72.000000   \n",
       "75%          6.000000                    140.250000                 80.000000   \n",
       "max         17.000000                    199.000000                122.000000   \n",
       "\n",
       "       triceps_thickness  serum_insulin         bmi  pedigree_function  \\\n",
       "count         768.000000     768.000000  768.000000         768.000000   \n",
       "mean           20.536458      79.799479   31.992578           0.471876   \n",
       "std            15.952218     115.244002    7.884160           0.331329   \n",
       "min             0.000000       0.000000    0.000000           0.078000   \n",
       "25%             0.000000       0.000000   27.300000           0.243750   \n",
       "50%            23.000000      30.500000   32.000000           0.372500   \n",
       "75%            32.000000     127.250000   36.600000           0.626250   \n",
       "max            99.000000     846.000000   67.100000           2.420000   \n",
       "\n",
       "              age  onset_disbetes  \n",
       "count  768.000000      768.000000  \n",
       "mean    33.240885        0.348958  \n",
       "std     11.760232        0.476951  \n",
       "min     21.000000        0.000000  \n",
       "25%     24.000000        0.000000  \n",
       "50%     29.000000        0.000000  \n",
       "75%     41.000000        1.000000  \n",
       "max     81.000000        1.000000  "
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pima.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "374\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "times_pregment                    0\n",
       "plasma_glucose_concentration      5\n",
       "diastolic_blood_pressure         35\n",
       "triceps_thickness               227\n",
       "serum_insulin                   374\n",
       "bmi                              11\n",
       "pedigree_function                 0\n",
       "age                               0\n",
       "onset_disbetes                    0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 处理被错误填充的缺失值0，还原为 空(单独处理)\n",
    "pima['serum_insulin'] = pima['serum_insulin'].map(lambda x:x if x !=0 else None)\n",
    "\n",
    "# 检查变量缺失情况\n",
    "print(pima['serum_insulin'].isnull().sum())\n",
    "\n",
    "# 批量操作 还原缺失值\n",
    "columns = ['serum_insulin','bmi','plasma_glucose_concentration','diastolic_blood_pressure','triceps_thickness']\n",
    "\n",
    "for col in columns:\n",
    "    pima[col].replace([0], [None], inplace=True)\n",
    "\n",
    "# 检查变量缺失情况\n",
    "pima.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "保留了原先 49% 的行\n"
     ]
    }
   ],
   "source": [
    "# 删除含有缺失值的行\n",
    "pima_dropped = pima.dropna()\n",
    "num_rows_lost = round(100*((pima.shape[0]-pima_dropped.shape[0])/pima.shape[0]))\n",
    "print(\"保留了原先 {}% 的行\".format(num_rows_lost))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'% change')"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 查看下 删除行 之后，各个特征均值的差异\n",
    "ax = (100*(pima_dropped.mean()-pima.mean())/pima.mean()).plot(kind='bar', title='各个特征均值的改变%')\n",
    "ax.set_ylabel('% change')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature = pima.drop('onset_disbetes', axis=1) # 取出特征"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "label = pima['onset_disbetes'] # 得到label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7317708333333334 {'classify__n_neighbors': 6}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    }
   ],
   "source": [
    "# 使用sklearn的 Pipeline以及 Imputer来实现缺失值填充\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.preprocessing import Imputer\n",
    "\n",
    "# 调参候选\n",
    "knn_params = {'classify__n_neighbors':[1,2,3,4,5,6]}\n",
    "\n",
    "# 实例化KNN模型\n",
    "knn = KNeighborsClassifier()\n",
    "\n",
    "# 管道设计\n",
    "mean_impute = Pipeline([('imputer', Imputer(strategy='mean')),\n",
    "                        ('classify',knn)\n",
    "                       ])\n",
    "# 网格搜索\n",
    "grid = GridSearchCV(mean_impute, knn_params)\n",
    "grid.fit(feature, label)\n",
    "\n",
    "# 打印模型效果\n",
    "print(grid.best_score_, grid.best_params_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据标准化 归一化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>times_pregment</th>\n",
       "      <th>plasma_glucose_concentration</th>\n",
       "      <th>diastolic_blood_pressure</th>\n",
       "      <th>triceps_thickness</th>\n",
       "      <th>serum_insulin</th>\n",
       "      <th>bmi</th>\n",
       "      <th>pedigree_function</th>\n",
       "      <th>age</th>\n",
       "      <th>onset_disbetes</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>6.0</td>\n",
       "      <td>148.0</td>\n",
       "      <td>72.0</td>\n",
       "      <td>35.00000</td>\n",
       "      <td>155.548223</td>\n",
       "      <td>33.6</td>\n",
       "      <td>0.627</td>\n",
       "      <td>50.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1.0</td>\n",
       "      <td>85.0</td>\n",
       "      <td>66.0</td>\n",
       "      <td>29.00000</td>\n",
       "      <td>155.548223</td>\n",
       "      <td>26.6</td>\n",
       "      <td>0.351</td>\n",
       "      <td>31.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>8.0</td>\n",
       "      <td>183.0</td>\n",
       "      <td>64.0</td>\n",
       "      <td>29.15342</td>\n",
       "      <td>155.548223</td>\n",
       "      <td>23.3</td>\n",
       "      <td>0.672</td>\n",
       "      <td>32.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.0</td>\n",
       "      <td>89.0</td>\n",
       "      <td>66.0</td>\n",
       "      <td>23.00000</td>\n",
       "      <td>94.000000</td>\n",
       "      <td>28.1</td>\n",
       "      <td>0.167</td>\n",
       "      <td>21.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.0</td>\n",
       "      <td>137.0</td>\n",
       "      <td>40.0</td>\n",
       "      <td>35.00000</td>\n",
       "      <td>168.000000</td>\n",
       "      <td>43.1</td>\n",
       "      <td>2.288</td>\n",
       "      <td>33.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   times_pregment  plasma_glucose_concentration  diastolic_blood_pressure  \\\n",
       "0             6.0                         148.0                      72.0   \n",
       "1             1.0                          85.0                      66.0   \n",
       "2             8.0                         183.0                      64.0   \n",
       "3             1.0                          89.0                      66.0   \n",
       "4             0.0                         137.0                      40.0   \n",
       "\n",
       "   triceps_thickness  serum_insulin   bmi  pedigree_function   age  \\\n",
       "0           35.00000     155.548223  33.6              0.627  50.0   \n",
       "1           29.00000     155.548223  26.6              0.351  31.0   \n",
       "2           29.15342     155.548223  23.3              0.672  32.0   \n",
       "3           23.00000      94.000000  28.1              0.167  21.0   \n",
       "4           35.00000     168.000000  43.1              2.288  33.0   \n",
       "\n",
       "   onset_disbetes  \n",
       "0             1.0  \n",
       "1             0.0  \n",
       "2             1.0  \n",
       "3             0.0  \n",
       "4             1.0  "
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "impute = Imputer(strategy='mean')\n",
    "pima_imputed_mean = pd.DataFrame(impute.fit_transform(pima),columns=pima_columns)\n",
    "pima_imputed_mean.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[<matplotlib.axes._subplots.AxesSubplot object at 0x000001FAA5EADF98>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x000001FAA60AAB38>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x000001FAA60C5E10>],\n",
       "       [<matplotlib.axes._subplots.AxesSubplot object at 0x000001FAA60E7358>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x000001FAA61019E8>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x000001FAA6101A20>],\n",
       "       [<matplotlib.axes._subplots.AxesSubplot object at 0x000001FAA613D668>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x000001FAA6327CF8>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x000001FAA63493C8>]],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1500x1500 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pima_imputed_mean.hist(figsize=(15,15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\preprocessing\\data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\base.py:464: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, **fit_params).transform(X)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(-9.25185853854297e-18, 1.0)"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# z分数标准化（单一特征）\n",
    "import sklearn\n",
    "# 实例化方法\n",
    "scaler = sklearn.preprocessing.StandardScaler()\n",
    "glucose_z_score_standarScaler = scaler.fit_transform(pima[['plasma_glucose_concentration']].fillna(-9))\n",
    "# 可以看看转换之后的均值和标准差是否为0和1\n",
    "glucose_z_score_standarScaler.mean(), glucose_z_score_standarScaler.std()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "times_pregment                  2.544261e-17\n",
      "plasma_glucose_concentration   -3.301757e-16\n",
      "diastolic_blood_pressure        6.966722e-16\n",
      "triceps_thickness               6.866252e-16\n",
      "serum_insulin                  -2.352033e-16\n",
      "bmi                             3.553292e-16\n",
      "pedigree_function               2.398978e-16\n",
      "age                             1.857600e-16\n",
      "onset_disbetes                  2.408374e-16\n",
      "dtype: float64 times_pregment                  1.000652\n",
      "plasma_glucose_concentration    1.000652\n",
      "diastolic_blood_pressure        1.000652\n",
      "triceps_thickness               1.000652\n",
      "serum_insulin                   1.000652\n",
      "bmi                             1.000652\n",
      "pedigree_function               1.000652\n",
      "age                             1.000652\n",
      "onset_disbetes                  1.000652\n",
      "dtype: float64\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1500x1500 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# z分数标准化（全部特征）\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "# 实例化方法\n",
    "scaler = sklearn.preprocessing.StandardScaler()\n",
    "pima_imputed_mean_scaled = pd.DataFrame(scaler.fit_transform(pima_imputed_mean), columns=pima_columns)\n",
    "# 看下标准化之后的分布\n",
    "pima_imputed_mean_scaled.hist(figsize=(15,15), sharex=True)\n",
    "print(pima_imputed_mean_scaled.mean(), pima_imputed_mean_scaled.std())\n",
    "\n",
    "# 在Pipeline中使用\n",
    "model = Pipeline([\n",
    "    ('imputer', Imputer()),\n",
    "    ('standardize', sklearn.preprocessing.StandardScaler())\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Step3: 标准化和归一化\n",
    "经过上面的处理，模型的精度可以达到0.73177，但我们可以继续优化吗？那是肯定的。\n",
    "\n",
    "我们可以先看看所有特征的分布（特征少的时候可以这么看）：\n",
    "\n",
    "我们重点关注3种方法：\n",
    "1）Z分数标准化\n",
    "\n",
    "最为常用的标准化技术，利用了统计学中的z分数思想，也就是将数据转换为均值为0，标准差为1的分布，其在python中的调用方法：\n",
    "\n",
    "z分数标准化（单一特征）\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "2）min-max标准化\n",
    "\n",
    "min-max标准化和z-score类似，其公式为：（X - Xmin)/(Xmax - Xmin)\n",
    "min-max标准化\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "3）行归一化\n",
    "\n",
    "行归一化针对的是每一行数据，不同于上面的两种方法（针对列），对行进行处理是为了保证每行的向量长度一样（也就是单位范围，unit norm），有L1、L2范数。\n",
    "行归一化\n",
    "from sklearn.preprocessing import Normalizer\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 03 特征构建\n",
    "如果我们对变量进行处理之后，效果仍不是非常理想，就需要进行特征构建了，也就是衍生新变量。\n",
    "\n",
    "而在这之前，我们需要了解我们的数据集，先前两节中我们了解到了可以通过 data.info 和 data.describe() 来查看，同时结合数据等级（定类、定序、定距、定比）来理解变量。\n",
    "\n",
    "通过特征提取，我们能得到**未经处理的特征**，这时的特征可能有以下问题：\n",
    "1. **不属于同一量纲**：即特征的规格不一样，不能够放在一起比较。无量纲化可以解决这一问题。\n",
    "> 无量纲化，标准化，归一化等等，缩放\n",
    "\n",
    "2. 信息**冗余**：对于某些定量特征，其包含的有效信息为区间划分，例如学习成绩，假若只关心“及格”或不“及格”，那么需要将定量的考分，转换成“1”和“0”表示及格和未及格。二值化可以解决这一问题。\n",
    "> **Cut** 对数据进行划分区间\n",
    "\n",
    "3. **定性特征**不能直接使用：某些机器学习算法和模型只能接受定量特征的输入，那么需要将定性特征转换为定量特征。最简单的方式是为每一种定性值指定一个定量值，但是这种方式过于灵活，增加了调参的工作。通常使用哑编码的方式将定性特征转换为定量特征：假设有N种定性值，则将这一个特征扩展为N种特征，当原始特征值为第i种定性值时，第i个扩展特征赋值为1，其他扩展特征赋值为0。哑编码的方式相比直接指定的方式，不用增加调参的工作，对于线性模型来说，使用哑编码后的特征可达到非线性的效果。 \n",
    ">定性特征用哑编码 one-hot\n",
    "\n",
    "4. ** 存在缺失值：缺失值需要补充。 \n",
    ">数据清洗，null值填充，0，中位数，平均值等。\n",
    "\n",
    "5. 信息利用率低：不同的机器学习算法和模型对数据中信息的利用是不同的，之前提到在线性模型中，使用对定性特征哑编码可以达到非线性的效果。类似地，对定量变量多项式化，或者进行其他的转换，都能达到非线性的效果。\n",
    "> 多项式**扩展特征**\n",
    "\n",
    "### 鸢尾花的特征预处理\n",
    "使用sklearn中的IRIS（鸢尾花）数据集来对特征处理功能进行说明。IRIS数据集由Fisher在1936年整理，包含4个特征（Sepal.Length（花萼长度）、Sepal.Width（花萼宽度）、Petal.Length（花瓣长度）、Petal.Width（花瓣宽度）），特征值都为正浮点数，单位为厘米。目标值为鸢尾花的分类（Iris Setosa（山鸢尾）、Iris Versicolour（杂色鸢尾），Iris Virginica（维吉尼亚鸢尾））。导入IRIS数据集的代码如下：\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(150, 4)\n",
      "[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
      " 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
      " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2\n",
      " 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2\n",
      " 2 2]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.datasets import load_iris\n",
    " \n",
    "#导入IRIS数据集\n",
    "iris = load_iris()\n",
    "\n",
    "#特征矩阵\n",
    "print(iris.data.shape)\n",
    "\n",
    "#目标向量\n",
    "print(iris.target)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 无量纲化，就是标准化，归一化等\n",
    "　无量纲化使不同规格的数据转换到同一规格。常见的无量纲化方法有标准化和区间缩放法。标准化的前提是特征值服从正态分布，标准化后，其转换成标准正态分布。区间缩放法利用了边界值信息，将特征的取值区间缩放到某个特点的范围，例如[0, 1]等。\n",
    " 1. 标准化，均值和标准差，\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "$$ \n",
    "x^{'} = \\frac{x - \\bar{X}} {S}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0 -1.4684549872375404e-15\n",
      "[[-0.90068117  1.01900435 -1.34022653 -1.3154443 ]\n",
      " [-1.14301691 -0.13197948 -1.34022653 -1.3154443 ]]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "#标准化，返回值为标准化后的数据\n",
    "iris_std_data1 = StandardScaler().fit_transform(iris.data)\n",
    "print(iris_std_data1.std(), iris_std_data1.mean())\n",
    "print(iris_std_data1[:2])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0 -1.4684549872375404e-15\n",
      "[[-0.90068117  1.01900435 -1.34022653 -1.3154443 ]\n",
      " [-1.14301691 -0.13197948 -1.34022653 -1.3154443 ]]\n"
     ]
    }
   ],
   "source": [
    "iris_std_data2 = (iris.data - iris.data.mean(axis = 0))/iris.data.std(axis = 0)\n",
    "print(iris_std_data2.std(), iris_std_data2.mean())\n",
    "print(iris_std_data2[:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "区间缩放法\n",
    "　　区间缩放法的思路有多种，常见的一种为利用两个最值进行缩放，公式表达为：\n",
    "\n",
    "　　使用preproccessing库的MinMaxScaler类对数据进行区间缩放的代码如下：\n",
    "  $$\n",
    "  x^{'} = \\frac{x - x_min} {x_max - x_min}\n",
    "  $$\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.4486931104833647 0.26236724966560704 1.0 0.0\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "#区间缩放，返回值为缩放到[0, 1]区间的数据\n",
    "data = MinMaxScaler().fit_transform(iris.data)\n",
    "print(data.mean(), data.std(),data.max(), data.min())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 标准化和归一化的区别\n",
    "\n",
    "1. 标准化，针对的是列向量，标准化是依照特征矩阵的列处理数据，其通过求z-score的方法，将样本的特征值转换到同一量纲下。\n",
    "2. 归一化 。归一化是依照特征矩阵的行处理数据，其目的在于样本向量在点乘运算或其他核函数计算相似性时，拥有统一的标准，也就是说都转化为“单位向量”。\n",
    "\n",
    "L2归一化的公式\n",
    "$$\n",
    "x^{'} = \\frac{x} {\\sqrt{\\sum_j^m x[j]^2}}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9999999999999998"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.preprocessing import Normalizer\n",
    "\n",
    "#归一化，返回值为归一化后的数据\n",
    "Normalized_data = Normalizer().fit_transform(iris.data)\n",
    "(Normalized_data[0]**2).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对定量特征二值化\n",
    "　　定量特征二值化的核心在于设定一个阈值，大于阈值的赋值为1，小于等于阈值的赋值为0，公式表达如下：\n",
    "$$ x^{'}=\\left\\{\n",
    "\\begin{array}{rcl}\n",
    "1     &      & {x>thres}\\\\\n",
    "0     &      & {x<= thres}\\\\\n",
    "\\end{array} \\right. $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 0., 0.])"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.preprocessing import Binarizer\n",
    "\n",
    "#二值化，阈值设置为3，返回值为二值化后的数据\n",
    "Binarizer(threshold=3).fit_transform(iris.data)[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  对定性特征哑编码\n",
    "　　由于IRIS数据集的特征皆为定量特征，故使用其目标值进行哑编码（实际上是不需要的）。使用preproccessing库的OneHotEncoder类对数据进行哑编码的代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import OneHotEncoder\n",
    "\n",
    "#哑编码，对IRIS数据集的目标值，返回值为哑编码后的数据\n",
    "data = OneHotEncoder(categories='auto').fit_transform(iris.target.reshape((-1,1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "缺失值计算　　由于IRIS数据集没有缺失值，故对数据集新增一个样本，4个特征均赋值为NaN，表示数据缺失。使用preproccessing库的Imputer类对数据进行缺失值计算的代码如下：from numpy import vstack, array, nan\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[nan nan nan nan]\n",
      "[5.84333333 3.05733333 3.758      1.19933333]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import Imputer\n",
    "from numpy import vstack, array, nan\n",
    "#缺失值计算，返回值为计算缺失值后的数据\n",
    "#参数missing_value为缺失值的表示形式，默认为NaN\n",
    "#参数strategy为缺失值填充方式，默认为mean（均值）\n",
    "data_with_nan = vstack((array([nan, nan, nan, nan]), iris.data))\n",
    "print(data_with_nan[0])\n",
    "data_without_nan = Imputer().fit_transform(data_with_nan)\n",
    "print(data_without_nan[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2.5 数据变换\n",
    "　　常见的数据变换有基于多项式的、基于指数函数的、基于对数函数的。4个特征，度为2的多项式转换公式如下：\n",
    "  使用preproccessing库的PolynomialFeatures类对数据进行多项式转换的代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(150, 35)"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "\n",
    "#多项式转换\n",
    "#参数degree为度，默认值为2\n",
    "PolynomialFeatures(degree=3).fit_transform(iris.data).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\preprocessing\\_function_transformer.py:98: FutureWarning: The default validate=True will be replaced by validate=False in 0.22.\n",
      "  \"validate=False in 0.22.\", FutureWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\preprocessing\\_function_transformer.py:98: FutureWarning: The default validate=True will be replaced by validate=False in 0.22.\n",
      "  \"validate=False in 0.22.\", FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(150, 4)"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#基于单变元函数的数据变换可以使用一个统一的方式完成，使用preproccessing库的FunctionTransformer对数据进行对数函数转换的代码如下：from numpy import log1p\n",
    "from numpy import log1p\n",
    "from sklearn.preprocessing import FunctionTransformer\n",
    "\n",
    "#自定义转换函数为对数函数的数据变换\n",
    "#第一个参数是单变元函数\n",
    "FunctionTransformer(log1p).fit_transform(iris.data).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "X = pd.DataFrame({'city':['tokyo',None,'london','seattle','san fancisco','tokyo'],\n",
    "                 'boolean':['y','n',None,'n','n','y'],\n",
    "                 'ordinal_column':['somewhat like','like','somewhat like','like','somewhat like','dislike'],\n",
    "                 'quantitative_column':[1,11,-.5,10,None,20]})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>city</th>\n",
       "      <th>boolean</th>\n",
       "      <th>ordinal_column</th>\n",
       "      <th>quantitative_column</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>tokyo</td>\n",
       "      <td>y</td>\n",
       "      <td>somewhat like</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>None</td>\n",
       "      <td>n</td>\n",
       "      <td>like</td>\n",
       "      <td>11.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>london</td>\n",
       "      <td>None</td>\n",
       "      <td>somewhat like</td>\n",
       "      <td>-0.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>seattle</td>\n",
       "      <td>n</td>\n",
       "      <td>like</td>\n",
       "      <td>10.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>san fancisco</td>\n",
       "      <td>n</td>\n",
       "      <td>somewhat like</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>tokyo</td>\n",
       "      <td>y</td>\n",
       "      <td>dislike</td>\n",
       "      <td>20.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           city boolean ordinal_column  quantitative_column\n",
       "0         tokyo       y  somewhat like                  1.0\n",
       "1          None       n           like                 11.0\n",
       "2        london    None  somewhat like                 -0.5\n",
       "3       seattle       n           like                 10.0\n",
       "4  san fancisco       n  somewhat like                  NaN\n",
       "5         tokyo       y        dislike                 20.0"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先我们需要对分类变量进行填充操作，类别变量一般用众数或者特殊值来填充，回顾之前的内容，我们也还是采取Pipeline的方式来进行，因此可以事先基于TransformMixin基类来对填充的方法进行封装，然后直接在Pipeline中进行调用，代码可以参考：\n",
    "\n",
    "### 缺失值用众数填充"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>city</th>\n",
       "      <th>boolean</th>\n",
       "      <th>ordinal_column</th>\n",
       "      <th>quantitative_column</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>tokyo</td>\n",
       "      <td>y</td>\n",
       "      <td>somewhat like</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>tokyo</td>\n",
       "      <td>n</td>\n",
       "      <td>like</td>\n",
       "      <td>11.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>london</td>\n",
       "      <td>n</td>\n",
       "      <td>somewhat like</td>\n",
       "      <td>-0.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>seattle</td>\n",
       "      <td>n</td>\n",
       "      <td>like</td>\n",
       "      <td>10.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>san fancisco</td>\n",
       "      <td>n</td>\n",
       "      <td>somewhat like</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>tokyo</td>\n",
       "      <td>y</td>\n",
       "      <td>dislike</td>\n",
       "      <td>20.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           city boolean ordinal_column  quantitative_column\n",
       "0         tokyo       y  somewhat like                  1.0\n",
       "1         tokyo       n           like                 11.0\n",
       "2        london       n  somewhat like                 -0.5\n",
       "3       seattle       n           like                 10.0\n",
       "4  san fancisco       n  somewhat like                  NaN\n",
       "5         tokyo       y        dislike                 20.0"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 填充分类变量（基于TransformerMixin的自定义填充器，用众数填充）\n",
    "from sklearn.base import TransformerMixin\n",
    "\n",
    "class CustomCategoryzImputer(TransformerMixin):\n",
    "   def __init__(self, cols=None):\n",
    "       self.cols = cols\n",
    "       \n",
    "   def transform(self, df):\n",
    "       X = df.copy()\n",
    "       for col in self.cols:\n",
    "           X[col].fillna(X[col].value_counts().index[0], inplace=True)\n",
    "       return X\n",
    "   \n",
    "   def fit(self, *_):\n",
    "       return self  \n",
    "   \n",
    "   \n",
    "# 调用自定义的填充器\n",
    "cci = CustomCategoryzImputer(cols=['city','boolean'])\n",
    "cci.fit_transform(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "又或者利用 scikit-learn 的 Imputer类来实现填充，而这个类有一个 Strategy的方法自然就被继承过来用了，包含的有mean、median、most_frequent可供选择。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>city</th>\n",
       "      <th>boolean</th>\n",
       "      <th>ordinal_column</th>\n",
       "      <th>quantitative_column</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>tokyo</td>\n",
       "      <td>y</td>\n",
       "      <td>somewhat like</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>None</td>\n",
       "      <td>n</td>\n",
       "      <td>like</td>\n",
       "      <td>11.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>london</td>\n",
       "      <td>None</td>\n",
       "      <td>somewhat like</td>\n",
       "      <td>-0.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>seattle</td>\n",
       "      <td>n</td>\n",
       "      <td>like</td>\n",
       "      <td>10.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>san fancisco</td>\n",
       "      <td>n</td>\n",
       "      <td>somewhat like</td>\n",
       "      <td>8.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>tokyo</td>\n",
       "      <td>y</td>\n",
       "      <td>dislike</td>\n",
       "      <td>20.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           city boolean ordinal_column  quantitative_column\n",
       "0         tokyo       y  somewhat like                  1.0\n",
       "1          None       n           like                 11.0\n",
       "2        london    None  somewhat like                 -0.5\n",
       "3       seattle       n           like                 10.0\n",
       "4  san fancisco       n  somewhat like                  8.3\n",
       "5         tokyo       y        dislike                 20.0"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 填充分类变量（基于Imputer的自定义填充器，用众数填充）\n",
    "from sklearn.preprocessing import Imputer\n",
    "class CustomQuantitativeImputer(TransformerMixin):\n",
    "   def __init__(self, cols=None, strategy='mean'):\n",
    "       self.cols = cols\n",
    "       self.strategy = strategy\n",
    "       \n",
    "   def transform(self, df):\n",
    "       X = df.copy()\n",
    "       impute = Imputer(strategy=self.strategy)\n",
    "       for col in self.cols:\n",
    "           X[col] = impute.fit_transform(X[[col]])\n",
    "       return X\n",
    "   \n",
    "   def fit(self, *_):\n",
    "       return self\n",
    "   \n",
    "   \n",
    "# 调用自定义的填充器\n",
    "cqi = CustomQuantitativeImputer(cols = ['quantitative_column'], strategy='mean')\n",
    "cqi.fit_transform(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>city</th>\n",
       "      <th>boolean</th>\n",
       "      <th>ordinal_column</th>\n",
       "      <th>quantitative_column</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>tokyo</td>\n",
       "      <td>y</td>\n",
       "      <td>somewhat like</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>tokyo</td>\n",
       "      <td>n</td>\n",
       "      <td>like</td>\n",
       "      <td>11.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>london</td>\n",
       "      <td>n</td>\n",
       "      <td>somewhat like</td>\n",
       "      <td>-0.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>seattle</td>\n",
       "      <td>n</td>\n",
       "      <td>like</td>\n",
       "      <td>10.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>san fancisco</td>\n",
       "      <td>n</td>\n",
       "      <td>somewhat like</td>\n",
       "      <td>8.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>tokyo</td>\n",
       "      <td>y</td>\n",
       "      <td>dislike</td>\n",
       "      <td>20.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           city boolean ordinal_column  quantitative_column\n",
       "0         tokyo       y  somewhat like                  1.0\n",
       "1         tokyo       n           like                 11.0\n",
       "2        london       n  somewhat like                 -0.5\n",
       "3       seattle       n           like                 10.0\n",
       "4  san fancisco       n  somewhat like                  8.3\n",
       "5         tokyo       y        dislike                 20.0"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 全部填充\n",
    "from sklearn.pipeline import Pipeline;\n",
    "\n",
    "imputer = Pipeline([('quant',cqi),\n",
    "                  ('category',cci)\n",
    "])\n",
    "\n",
    "imputer.fit_transform(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "填充完数据后，对分类变量进行编码，独热编码或者标签编码。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1）独热编码\n",
    "\n",
    "独热编码主要是针对**定类变量**的，也就是不同变量值之间是没有顺序大小关系的，我们一般可以使用 scikit_learn 里面的 OneHotEncoding来实现的，但我们这里还是使用自定义的方法来加深理解。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ordinal_column</th>\n",
       "      <th>quantitative_column</th>\n",
       "      <th>boolean_n</th>\n",
       "      <th>boolean_y</th>\n",
       "      <th>city_london</th>\n",
       "      <th>city_san fancisco</th>\n",
       "      <th>city_seattle</th>\n",
       "      <th>city_tokyo</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>somewhat like</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>like</td>\n",
       "      <td>11.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>somewhat like</td>\n",
       "      <td>-0.5</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>like</td>\n",
       "      <td>10.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>somewhat like</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>dislike</td>\n",
       "      <td>20.0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  ordinal_column  quantitative_column  boolean_n  boolean_y  city_london  \\\n",
       "0  somewhat like                  1.0          0          1            0   \n",
       "1           like                 11.0          1          0            0   \n",
       "2  somewhat like                 -0.5          0          0            1   \n",
       "3           like                 10.0          1          0            0   \n",
       "4  somewhat like                  NaN          1          0            0   \n",
       "5        dislike                 20.0          0          1            0   \n",
       "\n",
       "   city_san fancisco  city_seattle  city_tokyo  \n",
       "0                  0             0           1  \n",
       "1                  0             0           0  \n",
       "2                  0             0           0  \n",
       "3                  0             1           0  \n",
       "4                  1             0           0  \n",
       "5                  0             0           1  "
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 类别变量的编码（独热编码）\n",
    "class CustomDummifier(TransformerMixin):\n",
    "   def __init__(self, cols=None):\n",
    "       self.cols = cols\n",
    "       \n",
    "   def transform(self, X):\n",
    "       return pd.get_dummies(X, columns=self.cols)\n",
    "   \n",
    "   def fit(self, *_):\n",
    "       return self\n",
    "   \n",
    "\n",
    "# 调用自定义的填充器\n",
    "cd = CustomDummifier(cols=['boolean','city'])\n",
    "cd.fit_transform(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2）标签编码\n",
    "\n",
    "标签编码是针对**定序变量**的，也就是有顺序大小的类别变量，就好像案例中的变量ordinal_column的值（dislike、somewhat like 和 like 可以分别用0、1、2来表示），同样的可以写个自定义的标签编码器："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>city</th>\n",
       "      <th>boolean</th>\n",
       "      <th>ordinal_column</th>\n",
       "      <th>quantitative_column</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>tokyo</td>\n",
       "      <td>y</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>None</td>\n",
       "      <td>n</td>\n",
       "      <td>2</td>\n",
       "      <td>11.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>london</td>\n",
       "      <td>None</td>\n",
       "      <td>1</td>\n",
       "      <td>-0.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>seattle</td>\n",
       "      <td>n</td>\n",
       "      <td>2</td>\n",
       "      <td>10.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>san fancisco</td>\n",
       "      <td>n</td>\n",
       "      <td>1</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>tokyo</td>\n",
       "      <td>y</td>\n",
       "      <td>0</td>\n",
       "      <td>20.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           city boolean  ordinal_column  quantitative_column\n",
       "0         tokyo       y               1                  1.0\n",
       "1          None       n               2                 11.0\n",
       "2        london    None               1                 -0.5\n",
       "3       seattle       n               2                 10.0\n",
       "4  san fancisco       n               1                  NaN\n",
       "5         tokyo       y               0                 20.0"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 类别变量的编码（标签编码）\n",
    "class CustomEncoder(TransformerMixin):\n",
    "   def __init__(self, col, ordering=None):\n",
    "       self.ordering = ordering\n",
    "       self.col = col\n",
    "       \n",
    "   def transform(self, df):\n",
    "       X = df.copy()\n",
    "       X[self.col] = X[self.col].map(lambda x: self.ordering.index(x))\n",
    "       return X\n",
    "   \n",
    "   def fit(self, *_):\n",
    "       return self\n",
    "   \n",
    "\n",
    "# 调用自定义的填充器\n",
    "ce = CustomEncoder(col='ordinal_column', ordering=['dislike','somewhat like','like'])\n",
    "ce.fit_transform(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "数值变量分箱操作\n",
    "\n",
    "以上的内容是对类别变量的一些简单处理操作，也是比较常用的几种，接下来我们就对数值变量进行一些简单处理方法的讲解。\n",
    "\n",
    "有的时候，虽然变量值是连续的，但是只有转换成类别才有解释的可能，比如年龄，我们需要分成年龄段，这里我们可以使用pandas的 cut函数来实现。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>city</th>\n",
       "      <th>boolean</th>\n",
       "      <th>ordinal_column</th>\n",
       "      <th>quantitative_column</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>tokyo</td>\n",
       "      <td>y</td>\n",
       "      <td>somewhat like</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>None</td>\n",
       "      <td>n</td>\n",
       "      <td>like</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>london</td>\n",
       "      <td>None</td>\n",
       "      <td>somewhat like</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>seattle</td>\n",
       "      <td>n</td>\n",
       "      <td>like</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>san fancisco</td>\n",
       "      <td>n</td>\n",
       "      <td>somewhat like</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>tokyo</td>\n",
       "      <td>y</td>\n",
       "      <td>dislike</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           city boolean ordinal_column  quantitative_column\n",
       "0         tokyo       y  somewhat like                  0.0\n",
       "1          None       n           like                  1.0\n",
       "2        london    None  somewhat like                  0.0\n",
       "3       seattle       n           like                  1.0\n",
       "4  san fancisco       n  somewhat like                  NaN\n",
       "5         tokyo       y        dislike                  2.0"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 数值变量处理——cut函数\n",
    "class CustomCutter(TransformerMixin):\n",
    "   def __init__(self, col, bins, labels=False):\n",
    "       self.labels = labels\n",
    "       self.bins = bins\n",
    "       self.col = col\n",
    "       \n",
    "   def transform(self, df):\n",
    "       X = df.copy()\n",
    "       X[self.col] = pd.cut(X[self.col], bins=self.bins, labels=self.labels)\n",
    "       return X\n",
    "   \n",
    "   def fit(self, *_):\n",
    "       return self\n",
    "   \n",
    "\n",
    "# 调用自定义的填充器\n",
    "cc = CustomCutter(col='quantitative_column', bins=3)\n",
    "cc.fit_transform(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "综上，我们可以对上面自定义的方法一并在Pipeline中进行调用，Pipeline的顺序为：\n",
    "\n",
    "1）用imputer填充缺失值 ，NULL填充\n",
    "\n",
    "2）独热编码city和boolean ， 独热编码编码\n",
    "\n",
    "3）标签编码ordinal_column\n",
    "\n",
    "4）分箱处理quantitative_column\n",
    "\n",
    "代码为："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\utils\\deprecation.py:58: DeprecationWarning: Class Imputer is deprecated; Imputer was deprecated in version 0.20 and will be removed in 0.22. Import impute.SimpleImputer from sklearn instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ordinal_column</th>\n",
       "      <th>quantitative_column</th>\n",
       "      <th>boolean_n</th>\n",
       "      <th>boolean_y</th>\n",
       "      <th>city_london</th>\n",
       "      <th>city_san fancisco</th>\n",
       "      <th>city_seattle</th>\n",
       "      <th>city_tokyo</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   ordinal_column  quantitative_column  boolean_n  boolean_y  city_london  \\\n",
       "0               1                    0          0          1            0   \n",
       "1               2                    1          1          0            0   \n",
       "2               1                    0          1          0            1   \n",
       "3               2                    1          1          0            0   \n",
       "4               1                    1          1          0            0   \n",
       "5               0                    2          0          1            0   \n",
       "\n",
       "   city_san fancisco  city_seattle  city_tokyo  \n",
       "0                  0             0           1  \n",
       "1                  0             0           1  \n",
       "2                  0             0           0  \n",
       "3                  0             1           0  \n",
       "4                  1             0           0  \n",
       "5                  0             0           1  "
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.pipeline import Pipeline\n",
    "\n",
    "# 流水线封装\n",
    "pipe = Pipeline([('imputer',imputer),\n",
    "                ('dummify',cd),\n",
    "                ('encode',ce),\n",
    "                ('cut',cc)\n",
    "])\n",
    "\n",
    "# 训练流水线\n",
    "pipe.fit(X)\n",
    "\n",
    "# 转换流水线\n",
    "pipe.transform(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数据的变量扩展， 人体胸部加速度数据集\n",
    "# 人体胸部加速度数据集,标签activity的数值为1-7\n",
    "```\n",
    "1-在电脑前工作\n",
    "2-站立、走路和上下楼梯\n",
    "3-站立\n",
    "4-走路\n",
    "5-上下楼梯\n",
    "6-与人边走边聊\n",
    "7-站立着说话\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('./data/activity_recognizer/1.csv', header=None)\n",
    "df.columns = ['index','x','y','z','activity']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>index</th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "      <th>z</th>\n",
       "      <th>activity</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1502</td>\n",
       "      <td>2215</td>\n",
       "      <td>2153</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1667</td>\n",
       "      <td>2072</td>\n",
       "      <td>2047</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2.0</td>\n",
       "      <td>1611</td>\n",
       "      <td>1957</td>\n",
       "      <td>1906</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3.0</td>\n",
       "      <td>1601</td>\n",
       "      <td>1939</td>\n",
       "      <td>1831</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4.0</td>\n",
       "      <td>1643</td>\n",
       "      <td>1965</td>\n",
       "      <td>1879</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>5.0</td>\n",
       "      <td>1604</td>\n",
       "      <td>1959</td>\n",
       "      <td>1921</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>6.0</td>\n",
       "      <td>1640</td>\n",
       "      <td>1829</td>\n",
       "      <td>1940</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>7.0</td>\n",
       "      <td>1607</td>\n",
       "      <td>1910</td>\n",
       "      <td>1910</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>8.0</td>\n",
       "      <td>1546</td>\n",
       "      <td>2045</td>\n",
       "      <td>1910</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>9.0</td>\n",
       "      <td>1529</td>\n",
       "      <td>2049</td>\n",
       "      <td>1972</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   index     x     y     z  activity\n",
       "0    0.0  1502  2215  2153         1\n",
       "1    1.0  1667  2072  2047         1\n",
       "2    2.0  1611  1957  1906         1\n",
       "3    3.0  1601  1939  1831         1\n",
       "4    4.0  1643  1965  1879         1\n",
       "5    5.0  1604  1959  1921         1\n",
       "6    6.0  1640  1829  1940         1\n",
       "7    7.0  1607  1910  1910         1\n",
       "8    8.0  1546  2045  1910         1\n",
       "9    9.0  1529  2049  1972         1"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#可以看到，加速度只有xyz数据\n",
    "df.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(162501, 5)"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这边只介绍一种多项式生成新特征的办法，调用PolynomialFeatures来实现。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>x0</th>\n",
       "      <th>x1</th>\n",
       "      <th>x2</th>\n",
       "      <th>x0^2</th>\n",
       "      <th>x0 x1</th>\n",
       "      <th>x0 x2</th>\n",
       "      <th>x1^2</th>\n",
       "      <th>x1 x2</th>\n",
       "      <th>x2^2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1502.0</td>\n",
       "      <td>2215.0</td>\n",
       "      <td>2153.0</td>\n",
       "      <td>2256004.0</td>\n",
       "      <td>3326930.0</td>\n",
       "      <td>3233806.0</td>\n",
       "      <td>4906225.0</td>\n",
       "      <td>4768895.0</td>\n",
       "      <td>4635409.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1667.0</td>\n",
       "      <td>2072.0</td>\n",
       "      <td>2047.0</td>\n",
       "      <td>2778889.0</td>\n",
       "      <td>3454024.0</td>\n",
       "      <td>3412349.0</td>\n",
       "      <td>4293184.0</td>\n",
       "      <td>4241384.0</td>\n",
       "      <td>4190209.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1611.0</td>\n",
       "      <td>1957.0</td>\n",
       "      <td>1906.0</td>\n",
       "      <td>2595321.0</td>\n",
       "      <td>3152727.0</td>\n",
       "      <td>3070566.0</td>\n",
       "      <td>3829849.0</td>\n",
       "      <td>3730042.0</td>\n",
       "      <td>3632836.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1601.0</td>\n",
       "      <td>1939.0</td>\n",
       "      <td>1831.0</td>\n",
       "      <td>2563201.0</td>\n",
       "      <td>3104339.0</td>\n",
       "      <td>2931431.0</td>\n",
       "      <td>3759721.0</td>\n",
       "      <td>3550309.0</td>\n",
       "      <td>3352561.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1643.0</td>\n",
       "      <td>1965.0</td>\n",
       "      <td>1879.0</td>\n",
       "      <td>2699449.0</td>\n",
       "      <td>3228495.0</td>\n",
       "      <td>3087197.0</td>\n",
       "      <td>3861225.0</td>\n",
       "      <td>3692235.0</td>\n",
       "      <td>3530641.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       x0      x1      x2       x0^2      x0 x1      x0 x2       x1^2  \\\n",
       "0  1502.0  2215.0  2153.0  2256004.0  3326930.0  3233806.0  4906225.0   \n",
       "1  1667.0  2072.0  2047.0  2778889.0  3454024.0  3412349.0  4293184.0   \n",
       "2  1611.0  1957.0  1906.0  2595321.0  3152727.0  3070566.0  3829849.0   \n",
       "3  1601.0  1939.0  1831.0  2563201.0  3104339.0  2931431.0  3759721.0   \n",
       "4  1643.0  1965.0  1879.0  2699449.0  3228495.0  3087197.0  3861225.0   \n",
       "\n",
       "       x1 x2       x2^2  \n",
       "0  4768895.0  4635409.0  \n",
       "1  4241384.0  4190209.0  \n",
       "2  3730042.0  3632836.0  \n",
       "3  3550309.0  3352561.0  \n",
       "4  3692235.0  3530641.0  "
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 扩展数值特征\n",
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "\n",
    "x = df[['x','y','z']]\n",
    "y = df['activity']\n",
    "\n",
    "poly = PolynomialFeatures(degree=2, include_bias=False, interaction_only=False)\n",
    "\n",
    "x_poly = poly.fit_transform(x)\n",
    "pd.DataFrame(x_poly, columns=poly.get_feature_names()).head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1faa8bc0cf8>"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 查看热力图(颜色越深代表相关性越强)\n",
    "%matplotlib inline\n",
    "import seaborn as sns\n",
    "\n",
    "sns.heatmap(pd.DataFrame(x_poly, columns=poly.get_feature_names()).corr())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\model_selection\\_split.py:2053: FutureWarning: You should specify a value for 'cv' instead of relying on the default value. The default value will change from 3 to 5 in version 0.22.\n",
      "  warnings.warn(CV_WARNING, FutureWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\model_selection\\_split.py:652: Warning: The least populated class in y has only 1 members, which is too few. The minimum number of members in any class cannot be less than n_splits=3.\n",
      "  % (min_groups, self.n_splits)), Warning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7211894080651812 {'classify__n_neighbors': 5, 'poly_features__degree': 2, 'poly_features__interaction_only': True}\n"
     ]
    }
   ],
   "source": [
    "# 导入相关库\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.pipeline import Pipeline\n",
    "\n",
    "knn = KNeighborsClassifier()\n",
    "\n",
    "# 在流水线中使用\n",
    "pipe_params = {'poly_features__degree':[1,2,3],\n",
    "              'poly_features__interaction_only':[True,False],\n",
    "              'classify__n_neighbors':[3,4,5,6]}\n",
    "\n",
    "# 实例化流水线\n",
    "pipe = Pipeline([('poly_features',poly),\n",
    "                ('classify',knn)])\n",
    "\n",
    "# 网格搜索\n",
    "grid = GridSearchCV(pipe, pipe_params)\n",
    "grid.fit(x,y)\n",
    "\n",
    "print(grid.best_score_, grid.best_params_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 04 特征选择\n",
    "好了，经过了上面的特征衍生操作，我们现在拥有了好多好多的特征（变量）了，全部丢进去模型训练好不好？当然是不行了🚫，这样子既浪费资源又效果不佳，因此我们需要做一下 特征筛选 ，而特征筛选的方法大致可以分为两大类：基于统计的特征筛选 和 基于模型的特征筛选。\n",
    "\n",
    "\n",
    "\n",
    "在进行特征选择之前，我们需要搞清楚一个概念：到底什么是更好的？有什么指标可以用来量化呢？\n",
    "\n",
    "这大致也可以分为两大类：一类是模型指标，比如accuracy、F1-score、R^2等等，还有一类是元指标，也就是指不直接与模型预测性能相关的指标，如：模型拟合/训练所需的时间、拟合后的模型预测新实例所需要的时间、需要持久化（永久保存）的数据大小。\n",
    "\n",
    "我们可以通过封装一个方法，把上面提及到的指标封装起来，方便后续的调用，代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\model_selection\\_split.py:2053: FutureWarning: You should specify a value for 'cv' instead of relying on the default value. The default value will change from 3 to 5 in version 0.22.\n",
      "  warnings.warn(CV_WARNING, FutureWarning)\n",
      "C:\\Users\\Jarvis\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\model_selection\\_split.py:652: Warning: The least populated class in y has only 1 members, which is too few. The minimum number of members in any class cannot be less than n_splits=3.\n",
      "  % (min_groups, self.n_splits)), Warning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Accuracy:0.7211894080651812\n",
      "Best Parameters:{'classify__n_neighbors': 5, 'poly_features__degree': 2, 'poly_features__interaction_only': True}\n",
      "Average Time to Fit (s):0.134\n",
      "Average Time to Score (s):1.669\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "def get_best_model_and_accuracy(model, params, x, y):\n",
    "   grid = GridSearchCV(model,\n",
    "                       params,\n",
    "                       error_score=0.)\n",
    "   grid.fit(x,y)\n",
    "   \n",
    "   # 经典的性能指标\n",
    "   print(\"Best Accuracy:{}\".format(grid.best_score_))\n",
    "   # 得到最佳准确率的最佳参数\n",
    "   print(\"Best Parameters:{}\".format(grid.best_params_))\n",
    "   # 拟合的平均时间\n",
    "   print(\"Average Time to Fit (s):{}\".format(round(grid.cv_results_['mean_fit_time'].mean(), 3)))\n",
    "   \n",
    "   # 预测的平均时间\n",
    "   print(\"Average Time to Score (s):{}\".format(round(grid.cv_results_['mean_score_time'].mean(), 3)))\n",
    "   \n",
    "   \n",
    "############### 使用示例 ###############\n",
    "# 导入相关库\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.pipeline import Pipeline\n",
    "\n",
    "knn = KNeighborsClassifier()\n",
    "\n",
    "# 在流水线中使用\n",
    "pipe_params = {'poly_features__degree':[1,2,3],\n",
    "              'poly_features__interaction_only':[True,False],\n",
    "              'classify__n_neighbors':[3,4,5,6]}\n",
    "\n",
    "# 实例化流水线\n",
    "pipe = Pipeline([('poly_features',poly),\n",
    "                ('classify',knn)])\n",
    "\n",
    "# 网格搜索\n",
    "get_best_model_and_accuracy(pipe, pipe_params, x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过上面的操作，我们可以创建一个模型性能基准线，用于对比后续优化的效果。接下来介绍一些常用的特征选择方法。\n",
    "\n",
    "1）基于统计的特征选择\n",
    "**针对于单变量**，我们可以采用 **皮尔逊相关系数以及假设检验** 来选择特征。\n",
    "\n",
    "（1）皮尔逊相关系数可以通过 **corr()** 来实现，返回的值在-1到1之间，绝对值越大代表相关性越强；\n",
    "\n",
    "（2）假设检验也就是p值，作为一种统计检验，在特征选择中，假设测试得原则是：” 特征与响应变量没有关系“（零假设）为真还是假。我们需要对每个变量进行检测，检测其与target有没有显著关系。可以使用 SelectKBest 和 f_classif 来实现。一般P值是介于0-1之间，简而言之，p值越小，拒绝零假设的概率就越大，也就是这个特征与target关系更大。\n",
    "\n",
    "\n",
    "\n",
    "2）基于模型的特征选择\n",
    "（1）对于文本特征，sklearn.feature_extraction.text里的 CountVectorizer有自带的特征筛选的参数，分别是 max_features、min_df、max_df、stop_words，可以通过搜索这些参数来进行特征选择，可以结合 SelectKBest 来实现流水线。\n",
    "\n",
    "（2）针对🌲树模型，我们可以直接调用不同树模型算法里的 特征重要度 来返回特征重要度，比如 DecisionTreeClassifier里的feature_importances_，（除此之外还有RandomForest、GBDT、XGBoost、ExtraTreesClassifier等等）都可以直接返回每个特征对于本次拟合的重要度，从而我们可以剔除重要度偏低的特征，可以结合 SelectFromModel来实现流水线。\n",
    "\n",
    "（3）使用正则化来筛选变量（针对线性模型）。有两种常用的正则化方法：L1正则化（Lasso）和L2正则化（岭）。\n",
    "\n",
    "\n",
    "\n",
    "总结一下，有几点做特征选择的方法经验：\n",
    "（1）如果特征是分类变量，那么可以从SelectKBest开始，用卡方或者基于树的选择器来选择变量；\n",
    "\n",
    "（2）如果特征是定量变量，可以直接用线性模型和基于相关性的选择器来选择变量；\n",
    "\n",
    "（3）如果是二分类问题，可以考虑使用 SelectFromModel和SVC；\n",
    "\n",
    "（4）在进行特征选择前，还是需要做一下EDA。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当数据预处理完成后，我们需要选择有意义的特征输入机器学习的算法和模型进行训练。通常来说，从两个方面考虑来选择特征：\n",
    "\n",
    "1. 特征是否发散：如果一个特征不发散，例如**方差接近于0**，也就是说样本在这个特征上基本上没有差异，这个特征对于样本的**区分并没有什么用**。\n",
    "\n",
    "2. 特征与目标的相关性：这点比较显见，与目标相关性高的特征，应当优选选择。除方差法外，本文介绍的其他方法均从相关性考虑\n",
    "\n",
    "根据特征选择的形式又可以将特征选择方法分为3种：\n",
    "1. Filter：过滤法，按照**发散性**或者**相关性对各个特征进行评分**，设定阈值或者待选择阈值的个数，选择特征。\n",
    "\n",
    "2. Wrapper：包装法，根据目标函数（通常是预测效果评分），每次选择若干特征，或者排除若干特征。\n",
    "\n",
    "3. Embedded：嵌入法，先使用某些机器学习的算法和模型进行训练，得到各个特征的权值系数，根据系数从大到小选择特征。类似于Filter方法，但是是通过训练来确定特征的优劣。　　我们使用sklearn中的feature_selection库来进行特征选择。\n",
    "\n",
    "### Filter 方法\n",
    "方差选择法\n",
    "使用方差选择法，先要计算各个特征的方差，然后根据阈值，选择方差大于阈值的特征。使用feature_selection库的VarianceThreshold类来选择特征的代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(150, 2)"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.feature_selection import VarianceThreshold\n",
    "\n",
    "#方差选择法，返回值为特征选择后的数据\n",
    "#参数threshold为方差的阈值\n",
    "VarianceThreshold(threshold=0.6).fit_transform(iris.data).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "相关系数法\n",
    "　　使用相关系数法，先要计算各个特征对目标值的相关系数以及相关系数的P值。用feature_selection库的SelectKBest类结合相关系数来选择特征的代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 7.82561232e-01, -4.26657561e-01,  9.49034699e-01,\n",
       "         9.56547333e-01],\n",
       "       [ 2.89047835e-32,  5.20156326e-08,  4.20187315e-76,\n",
       "         4.15531102e-81]])"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1 = np.array([[1,3,4],[3,4,2],[3,4,2]])\n",
    "x2 = np.array([1,2,3])\n",
    "fun1(iris.data,iris.target)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [],
   "source": [
    "fun1 = lambda X, Y: array(list(map(lambda x: pearsonr(x, Y), X.T))).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "index 2 is out of bounds for axis 0 with size 2",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-204-eb8844122fdf>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[1;31m#输出二元组（评分，P值）的数组，数组第i项为第i个特征的评分和P值。在此定义为计算相关系数\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[1;31m#参数k为选择的特征个数\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 8\u001b[1;33m \u001b[0mSelectKBest\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfun1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mk\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0miris\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0miris\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtarget\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\base.py\u001b[0m in \u001b[0;36mfit_transform\u001b[1;34m(self, X, y, **fit_params)\u001b[0m\n\u001b[0;32m    465\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    466\u001b[0m             \u001b[1;31m# fit method of arity 2 (supervised transformation)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 467\u001b[1;33m             \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mfit_params\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    468\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    469\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\feature_selection\\base.py\u001b[0m in \u001b[0;36mtransform\u001b[1;34m(self, X)\u001b[0m\n\u001b[0;32m     74\u001b[0m         \"\"\"\n\u001b[0;32m     75\u001b[0m         \u001b[0mX\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcheck_array\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maccept_sparse\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'csr'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 76\u001b[1;33m         \u001b[0mmask\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_support\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     77\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mmask\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0many\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     78\u001b[0m             warn(\"No features were selected: either the data is\"\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\feature_selection\\base.py\u001b[0m in \u001b[0;36mget_support\u001b[1;34m(self, indices)\u001b[0m\n\u001b[0;32m     45\u001b[0m             \u001b[0mvalues\u001b[0m \u001b[0mare\u001b[0m \u001b[0mindices\u001b[0m \u001b[0minto\u001b[0m \u001b[0mthe\u001b[0m \u001b[0minput\u001b[0m \u001b[0mfeature\u001b[0m \u001b[0mvector\u001b[0m\u001b[1;33m.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     46\u001b[0m         \"\"\"\n\u001b[1;32m---> 47\u001b[1;33m         \u001b[0mmask\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_get_support_mask\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     48\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0mmask\u001b[0m \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mindices\u001b[0m \u001b[1;32melse\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwhere\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmask\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     49\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\feature_selection\\univariate_selection.py\u001b[0m in \u001b[0;36m_get_support_mask\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m    527\u001b[0m             \u001b[1;31m# Request a stable sort. Mergesort takes more memory (~40MB per\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    528\u001b[0m             \u001b[1;31m# megafeature on x86-64).\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 529\u001b[1;33m             \u001b[0mmask\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0margsort\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mscores\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkind\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"mergesort\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mk\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    530\u001b[0m             \u001b[1;32mreturn\u001b[0m \u001b[0mmask\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    531\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mIndexError\u001b[0m: index 2 is out of bounds for axis 0 with size 2"
     ]
    }
   ],
   "source": [
    "from sklearn.feature_selection import SelectKBest\n",
    "from scipy.stats import pearsonr\n",
    "\n",
    "#选择K个最好的特征，返回选择特征后的数据\n",
    "#第一个参数为计算评估特征是否好的函数，该函数输入特征矩阵和目标向量，\n",
    "#输出二元组（评分，P值）的数组，数组第i项为第i个特征的评分和P值。在此定义为计算相关系数\n",
    "#参数k为选择的特征个数\n",
    "SelectKBest(fun1, k=2).fit_transform(iris.data, iris.target)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "卡方检验　　经典的卡方检验是检验定性自变量对定性因变量的相关性。假设自变量有N种取值，因变量有M种取值，考虑自变量等于i且因变量等于j的样本频数的观察值与期望的差距，构建统计量：<img src=\"https://pic2.zhimg.com/50/7bc586c806b9b8bf1e74433a2e1976bc_hd.jpg\" data-rawwidth=\"162\" data-rawheight=\"48\" class=\"content_image\" width=\"162\"/>　　不难发现，这个统计量的含义简而言之就是自变量对因变量的相关性。用feature_selection库的SelectKBest类结合卡方检验来选择特征的代码如下：\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(150, 2)"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.feature_selection import SelectKBest\n",
    "from sklearn.feature_selection import chi2\n",
    "\n",
    "#选择K个最好的特征，返回选择特征后的数据\n",
    "SelectKBest(chi2, k=2).fit_transform(iris.data, iris.target).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "互信息法　　经典的互信息也是评价定性自变量对定性因变量的相关性的，互信息计算公式如下：<img src=\"https://pic3.zhimg.com/50/6af9a077b49f587a5d149f5dc51073ba_hd.jpg\" data-rawwidth=\"274\" data-rawheight=\"50\" class=\"content_image\" width=\"274\"/>　　为了处理定量数据，最大信息系数法被提出，使用feature_selection库的SelectKBest类结合最大信息系数法来选择特征的代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Looking in indexes: https://pypi.tuna.tsinghua.edu.cn/simple\n",
      "Collecting minepy\n",
      "  Downloading https://pypi.tuna.tsinghua.edu.cn/packages/90/a6/cdfe0f50b16d18196b3a21d3df8c06c361ccbd553717093133a88227823b/minepy-1.2.4.tar.gz (493kB)\n",
      "Requirement already satisfied: numpy>=1.3.0 in d:\\python36\\lib\\site-packages (from minepy) (1.16.4)\n",
      "Building wheels for collected packages: minepy\n",
      "  Building wheel for minepy (setup.py): started\n",
      "  Building wheel for minepy (setup.py): finished with status 'done'\n",
      "  Stored in directory: C:\\Users\\Jarvis\\AppData\\Local\\pip\\Cache\\wheels\\9f\\86\\4f\\9f142762df1b7281f172865cd449da8d8b1792c1bbf40bee62\n",
      "Successfully built minepy\n",
      "Installing collected packages: minepy\n",
      "Successfully installed minepy-1.2.4\n"
     ]
    }
   ],
   "source": [
    "!pip install minepy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "index 2 is out of bounds for axis 0 with size 2",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-192-f3432ea7a15e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[1;31m#选择K个最好的特征，返回特征选择后的数据\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 11\u001b[1;33m \u001b[0mSelectKBest\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;32mlambda\u001b[0m \u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mY\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmap\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m:\u001b[0m\u001b[0mmic\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mY\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mX\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mT\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mT\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mk\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0miris\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0miris\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtarget\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\base.py\u001b[0m in \u001b[0;36mfit_transform\u001b[1;34m(self, X, y, **fit_params)\u001b[0m\n\u001b[0;32m    465\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    466\u001b[0m             \u001b[1;31m# fit method of arity 2 (supervised transformation)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 467\u001b[1;33m             \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mfit_params\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    468\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    469\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\feature_selection\\base.py\u001b[0m in \u001b[0;36mtransform\u001b[1;34m(self, X)\u001b[0m\n\u001b[0;32m     74\u001b[0m         \"\"\"\n\u001b[0;32m     75\u001b[0m         \u001b[0mX\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcheck_array\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maccept_sparse\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'csr'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 76\u001b[1;33m         \u001b[0mmask\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_support\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     77\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mmask\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0many\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     78\u001b[0m             warn(\"No features were selected: either the data is\"\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\feature_selection\\base.py\u001b[0m in \u001b[0;36mget_support\u001b[1;34m(self, indices)\u001b[0m\n\u001b[0;32m     45\u001b[0m             \u001b[0mvalues\u001b[0m \u001b[0mare\u001b[0m \u001b[0mindices\u001b[0m \u001b[0minto\u001b[0m \u001b[0mthe\u001b[0m \u001b[0minput\u001b[0m \u001b[0mfeature\u001b[0m \u001b[0mvector\u001b[0m\u001b[1;33m.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     46\u001b[0m         \"\"\"\n\u001b[1;32m---> 47\u001b[1;33m         \u001b[0mmask\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_get_support_mask\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     48\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0mmask\u001b[0m \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mindices\u001b[0m \u001b[1;32melse\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwhere\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmask\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     49\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python36\\site-packages\\sklearn\\feature_selection\\univariate_selection.py\u001b[0m in \u001b[0;36m_get_support_mask\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m    527\u001b[0m             \u001b[1;31m# Request a stable sort. Mergesort takes more memory (~40MB per\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    528\u001b[0m             \u001b[1;31m# megafeature on x86-64).\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 529\u001b[1;33m             \u001b[0mmask\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0margsort\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mscores\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkind\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"mergesort\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mk\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    530\u001b[0m             \u001b[1;32mreturn\u001b[0m \u001b[0mmask\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    531\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mIndexError\u001b[0m: index 2 is out of bounds for axis 0 with size 2"
     ]
    }
   ],
   "source": [
    "from sklearn.feature_selection import SelectKBest\n",
    "from minepy import MINE\n",
    " \n",
    " #由于MINE的设计不是函数式的，定义mic方法将其为函数式的，返回一个二元组，二元组的第2项设置成固定的P值0.5\n",
    "def mic(x, y):\n",
    "    m = MINE()\n",
    "    m.compute_score(x, y)\n",
    "    return (m.mic(), 0.5)\n",
    "\n",
    "#选择K个最好的特征，返回特征选择后的数据\n",
    "SelectKBest(lambda X, Y: array(list(map(lambda x:mic(x, Y), X.T))).T, k=2).fit_transform(iris.data, iris.target)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 05 特征转换\n",
    "经过了上面几个环节的“洗礼”，我们来到特征转换的环节，也就是使用源数据集的隐藏结构来创建新的列，常用的办法有2种：PCA和LDA。\n",
    "✅ PCA：\n",
    "PCA，即主成分分析（Principal Components Analysis），是比较常见的数据压缩的办法，即将多个相关特征的数据集投影到相关特征较少的坐标系上。也就是说，转换后的特征，在解释性上就走不通了，因为你无法解释这个新变量到底具有什么业务逻辑了。\n",
    "PCA的原理这里就不展开来讲了，太多的文章把它讲得十分透彻了。这里主要是复现一下PCA在sklearn上的调用方法，一来继续熟悉下Pipeline的使用，二来理解一下PCA的使用方法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 导入相关库\n",
    "from sklearn.datasets import load_iris\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "# 导入数据集\n",
    "iris = load_iris()\n",
    "iris_x, iris_y = iris.data, iris.target\n",
    "\n",
    "# 实例化方法\n",
    "pca = PCA(n_components=2)\n",
    "# 训练方法\n",
    "pca.fit(iris_x)\n",
    "pca.transform(iris_x)[:5,]\n",
    "\n",
    "# 自定义一个可视化的方法\n",
    "label_dict = {i:k for i,k in enumerate(iris.target_names)}\n",
    "def plot(x,y,title,x_label,y_label):\n",
    "   ax = plt.subplot(111)\n",
    "   for label,marker,color in zip(\n",
    "   range(3),('^','s','o'),('blue','red','green')):\n",
    "       plt.scatter(x=x[:,0].real[y == label],\n",
    "                  y = x[:,1].real[y == label],\n",
    "                  color = color,\n",
    "                  alpha = 0.5,\n",
    "                  label = label_dict[label]\n",
    "                  )\n",
    "       \n",
    "   plt.xlabel(x_label)\n",
    "   plt.ylabel(y_label)\n",
    "   \n",
    "   leg = plt.legend(loc='upper right', fancybox=True)\n",
    "   leg.get_frame().set_alpha(0.5)\n",
    "   plt.title(title)\n",
    "\n",
    "# 可视化\n",
    "plot(iris_x, iris_y,\"original iris data\",\"sepal length(cm)\",\"sepal width(cm)\")\n",
    "plt.show()\n",
    "\n",
    "plot(pca.transform(iris_x), iris_y,\"Iris: Data projected onto first two PCA components\",\"PCA1\",\"PCA2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上是PCA在sklearn上的简单调用和效果展示，另外，作者提出了一个很有意思的问题：\n",
    "一般而言，对特征进行归一化处理后会对机器学习算法的效果有比较明显的帮助，但为什么在书本的例子却是相反呢？\n",
    "\n",
    "\n",
    ">给出的解释是：在对数据进行缩放后，列与列之间的协方差会更加一致，而且每个主成分解释的方差会变得分散，而不是集中在某一个主成分上。所以，在实际操作的时候，都要对缩放的未缩放的数据进行性能测试才是最稳妥的哦。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.4644999999999997 1.9738430577598278\n",
      "-1.4684549872375404e-15 1.0\n"
     ]
    }
   ],
   "source": [
    "iris_x.shape\n",
    "print(iris_x.mean(), iris_x.std())\n",
    "iris_x_normalized = (iris_x - iris_x.mean(axis = 0))/iris_x.std(axis = 0)\n",
    "print(iris_x_normalized.mean(), iris_x_normalized.std())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-2.26470281,  0.4800266 ],\n",
       "       [-2.08096115, -0.67413356],\n",
       "       [-2.36422905, -0.34190802],\n",
       "       [-2.29938422, -0.59739451],\n",
       "       [-2.38984217,  0.64683538]])"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pca.fit(iris_x_normalized)\n",
    "pca.transform(iris_x_normalized)[:5,]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAESCAYAAAAR2wXeAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztvXt8VOWd+P/+kNuESy7IHYyIouHSCIgKVBERvopatan9VbfrasGl2nZ7datba5tua+t2qVVXq6UtpRdt62pWrfdSDSABFRFDFFBUGkECCMmEQG6Q5/fHcyaZDHPP3Ofzfr3mNTNnzjnPc+Y853M+53N7xBiDoiiKkh0MSHYHFEVRlMShQl9RFCWLUKGvKIqSRajQVxRFySJU6CuKomQRKvQVRVGyCBX6ARCRnSIyM8Bvm0WkJMr9Xi8ibmcfb4hIvYisEpEZYW6/QkTOjKbt/iAiM0Xk0X5s/wMRuTLCbYaJSMxiikXkbBH5VRTbrRSRf4hIlYg8IyKTI9z+RREZ5mf5BBF5PNL+hNGe7xjbJCLrROQcr3XKROQhEdkhIm+KyAYRudTPvh4TkQMiMijW/UwX4nWekkVusjuQjhhjpvVzF2uNMZd5vojIxcBzIjLNGPNRiG3nA7/oZ/sRY4zZCFzVj12cD2yJUXeiZTIwOort/hk4yRizO8p2LwiwvAw4Ncp9hsJ3jF0KPAaME5GRQC3wfWPM553fpwEviMjnjDEvOcvGAOcB64Drgfvj1NdUJ57nKfEYY/Tl5wXsBGY6n48CK4DtwJmAAYYBJwGrga1APfANr+03e7b32e/1wFN+lv8W+C/n85nOfl8HPgR+AwhwB9Dp9OMc4GTgeWe9BuBxYKCffVcBK4G1wFvAH4DBXsf5O+Bt4ErgE8CLQB3wJnCts948oN757ALuBTYBrzn79uzvbGCD83+8DlwIfBloBT4APh1i+0uctjcBv7JD1O/5OR9Y7/TxNeBir36+DPzRaf9Np08nOv+RG/its+6N2BtRnfM/nuannbXO+d4CzPGMC6edN4FVzvYjgb865+Ytr3P5W6/tT/Tabw6wA2hz2v4z8BXnt+nONpOc7zcD93j9b/XO/n4FDAlnjAEDnX0OBX4IPBLgP53qM27+DHzOOS4JcC4GOefwXew4+gl2vA7FjrUtTp//C8h1tmkH/tM5h/XOef9f5/OLwCCv8XmHcy7fBr7g1a7f8+f0+zfOual3fhvu/Haic55eB14F/sNZPt45H/dix9M24FI/56kAe73scNpeAeQnW15FJNuS3YFUfdFX6Bvgn7x+8wj9u4GfOcuKgWqgIMR+j7sgneVfAZ5zPj8KzHU+DwH2AVP89OtuT7+AfKwQutTPvquwAm+EczE+TK9Q2gl8x/mchxXMVznfxwK7sMJuHr1Cvwr4GY4QcL7/3OnDHuASZ/lM58IQoMZrv4G2Hw4coFfYfQM/Qt9Z72NglvN9ivP9ZKefXcCZzm/fAv7u+98DC4H3gBHO9y9gb97HCTbP+fb+/73aOclZ/nXgMa//8Y/AGN/tffbr/Z/+f8DTzuf/cP6Hrzrf1wBzscLv/5z9D8AKnAdDjTFn3X8HtjjfnwG+FmKc5gK7gU9hbzZN+Blbzrp3AX9y2sl3+jsPeAj4H+f8u7BC81av/+TLzuebgRZgrPN9I73jeqfnGLHjcR8wNdj5w46n94Chzm9PArc7n2uAy73O0wvAFVihb4ArnN8+A7zn5zxdCbzufBbn+KYlW15F8lKbfvis9rPsGeA6EXkG+Fespt8R5f4NVhsGuAYYIiL/AdyH1aSOswljhWKjiNyMffQeG2A9gL8YY/YZO1p/g71oPHiO7XSs1vIogLHmjMeAi3z2dSlwOfCGiGzGCqzTsE8Jx4wxzzjbbzTGfMJpM5ztZwFvG2O2OustD3As5wDbjTEbnHbewpog5jm/v2+Med35/Ab2ZufLRcCfjTH7nH38FhiDvfjDZacx5h/O55eAOSLyEnAL8GMT2lTnzTPAbBFxARdjteWFji/gFOzTy0XAL4wxXcaYbqzAWRRgf+d5bPpYIVqB/c8BDhPatHuFs86zxph24C/YG5s/FgK/McZ0G2M6jTFzjTE1Tn/vNZZ24EGf/j7lvO/E3pA85rMd2KcED/8DPePxeayJM9T5W2WMOeh83gyMEJHB2Jvnfzrj7jVgAvYmAtBpjHnC+Rxo3LwGlIrIK8CPgD8YYzYH+F9SErXph89xwtwY84KITMAO+oXAZhG5IMpBcCZQJyIDsOaRDdgB/jDWrip+tql2+vW/WG3m1ADrgdVKPQjWZOXB+9h8BbRgTUreDAD+zRjzHIBzMbmw9vLuPhtbp+c7YW4/G/v47OGon/6E00/vY+0m8H8SzrEGo+d/M8a86YyFC4AFwFoRudZzAwyFMaZVRGqxmvU44AHszeNK4EljTLeI+PY5WH/72PR9eA174+yDiNwIFBpjfg58CasJ1zvtuoCTRGSqMabeZ9NOvM67iIzFmm9C9few12fvc+ZLoLEb6RjwjIM5xpgjTl+HA0ewT48hx40xZreInIa9JhcAT4hIlTHml0H6n1Kopt8PRORB4NvGmMew5pldROEoFJFFwGXYC70YmAZ81xjzJFYDHo+1LQIco1cwzsdqlI9hL8qzvNbz5dMiUuTcVJZg7Zq+vAMcFZFKp1+jsTb4VT7rPQv8m4gUiJUI92FNEtuAbhFZ4Gw/Ffs4PcCn34G2X4cVLJ6oqevwL7BfAU4XkbOddiZhTVAvBzh2D959eAG42hNVIyLXAQ0mSmet81T2S2PMM8aYbzp9PMn5uZu+NzN//QF7E/8R8JIx5jDWXPdd7NOWp883iUie87992VkWKQ8A54rI9V79PxNrY3/TEWpzsWbEcuc1HvtE+DU/+3se+8QrIpILPIL1D7wAfMVZng98Mcr+Xu/0cRx2zL9AFOfPGHMI68D+prPNYOwT2vwQ7fecJxH5vHO8a4wxt2H9aBOiOKakoUK/f/wE+0i+BfsI+Zzz8oR1+g35pPfRe7OIvIV9bL7EGLPfGNOEvfA3icha7OPwU1jTC8ATwB8dwXoL8H8isg57Mf7Zaz1f9jl9qwMOAj/1XcEY04k1AXxFRN7EmhxuNca84rPqj4D3sc5Wj9b3XWNMF1AJVDmPzyuwdvxO7E3mThG5Nsj2B4Grgd+IyCZgor8DMcbsx0YS3eP0cyXWBvwPf+t7sQ4oF5FHjTEvYP0KL4pIHdZZGVFIqQ8PAINF5C1nPOzDOnHB2uFfEpEpPttswd4k1zvfn8SacjyC8TmsT6fG+f6fwEdY08MWrMb77Ug76gi/+VhFYIfT3/uxTtIXgZuA/zPGvO+z6Q+Bf/YTfuoJMHgTex2sMsZUYxWhE5y+bnJed0XaX+BkZzw8jfUD7OjH+fs8cI5zzK8CvzPG+FOAvPE+T/+L9XvVO2NvDH6upVTG40hTMhgRqcI6Er/Sj31cgb0BzI5ZxxQlBCKyE6s4bEx2XzIF1fSVkIjIV7DO3z8muy+KovQP1fQVRVGyCNX0FUVRsggV+oqiKFlEysXpDxs2zIwfPz7Z3VAURUkrXn/99Y+NMcNDrZdyQn/8+PFs3KiOekVRlEgQkVAhy4CadxRFUbIKFfqKoihZhAp9RVGULCLlbPqKomQHx44d4+DBg3R1Bau1pviSl5fH0KFDyckJVGYrOCr0FUVJCgcPHsTlcjFs2DCcSp5KCIwxtLa2cvDgQYYPDxmo4xc17yiKkhS6uroYPHiwCvwIEBEGDx7cr6cj1fQjoK4OqquhoQHKyqCyEioqkt0rRUlfVOBHTn//M9X0w6SuDpYtg6YmGDfOvi9bZpcriqKkC6rph0l1NZSW2hf0vldXq7avKIlmb+tetn68FXe7m2JXMZOGTWLk4JFxaWvNmjWUlJRQkSEXumr6YdLQAMXFfZcVF9vliqLEn7o6qKqCa649wldvOcjbW3IoKiiirauN2g9r2du6Ny7trlixgo8+imS649RGNf0wKSuzJh2Phg/gdtvliqLEF495tbQU8kr34Xa7eOK3Eyn41w85ZZK1cW/9eGtE2v67777L9ddfjzGGAQMG8Kc//Yn777+fNWvW4HK5uO6665g6dSrPPfccmzZtYvLkyaxfv5677rqL/Px8Tj/9dB544AF27tx53H5GjhzJ0qVLeffdd3G73SxatIj//u//jtffExEq9MOkstIOOrAavtttbwJLliS3X4qSDXibV/d+3E5JSQGtA46y9vlhnDLpMK5cF+52d0Rmn+eee44zzzyTn/3sZ6xbt47q6mree+891q1bx7Fjxzj33HN56qmnuPjii7n66qsZNGgQ3/3ud9m0aRNDhgzhm9/8JsuXL6e7u7vPfg4ePEhHRwcXXnghK1eu5MiRI5xyyikpI/TVvBMmFRVw88120O3aZd9vvlnt+YqSCLzNq65cF0e7jzJoyFH27nYB0H60nZwBOdR+WEtbV1tYZp8bbriBUaNGcckll3D33XfT3NzM5s2bueCCC1iwYAGtra28/37vNMHvvfceU6ZMYciQIQBccMEFvP3228ftJy8vj+HDh7NhwwauueYavvnNb9La2hrfPygCVNOPgIoKFfKKkgy8zavDBg7jQ/eHtLbmMmJMO21dbbQfbScvJw9XrovCvEKAnvdAZp8nnniCiooKvvOd7/Dwww9z++23c+GFF/Zo73feeScTJ04kJyeHY8eOMWHCBLZs2cKhQ4cYMmQIL774IpMnTz5uP3fddRdTp06lpKSE+++/nw8++IBf//rXGGNSIkRVhb6iKClPX/PqYIpMGc2HDjGj8m0K8wqZMXoGG3ZtYFDBoD7becw+/jjrrLP4whe+wM9+9jM6Ojr405/+xCOPPMJ5551Ha2srl112GaWlpcyaNYtvfetbPP744/zwhz9kwYIF5OfnM3HiRJYuXUpDQ0Of/dx9990MHjyYq6++mldeeYXJkydTUVHB7t27GTduXLz/qpCk3By5M2fONFpPX1Eyn48++ogxY8aEvX6o5MianTW0dbX1aPhAz/d54+fFsOfJx99/JyKvG2NmhtpWNX1FUdKCUObVScMmUfthLWA1/Paj7bQfbWfG6BkJ6mF6oI5cRVEygpGDRzLnxDkU5hXS0tFCYV4hc06cE7ekrXRFNX1FUTKGkYNHqpAPgWr6iqIoWYQKfUVRlCxChb6iKEoWoUJfURSlHzz33HMsX748om2qqqp48MEH49Sj4KgjV1GU9CBFZzG6+OKLk92FiFBNX1GU1CcOsxh99rOfZc2aNQC89tprfOYzn2Hx4sWcd955zJ8/n+effx6AqVOncs0113DddddRW1vL2WefzezZs7noootoaWlh5cqV3HrrrQD84Ac/4Nxzz2XGjBk92v8999zDOeecw5w5c/jOd75zXD9uvfVWZs+ezTnnnMN9990HwPXXX89VV13FvHnzaG5ujvoY/aFCX1GU1Me7zOaAAb2fq6uj3uUNN9zA7373OwBWrlzJggULKC0tZe3atTz55JPccsstHD16lNbWVm655RZ+97vf8dhjj/HZz36WdevW8eUvf5kDBw707G/jxo08//zzrF69mnXr1vHWW2+xZcsWHn74YV5++WXWrVvH9u3befrpp3u2eeqpp3jnnXeora3l5Zdf5qGHHmLLli0AnHvuudTU1FBSUhL1MfpDzTsOKfrkqCgK2AvTt25NP2cxWrhwIf/+7/9Oc3MzL7/8Mt3d3bz88svMmzcPgPb2dvbt2wfA6aefDsBtt93GsmXLWLBgAaNGjeLMM8/s2d+OHTs455xzyMnJobCwkHvuuYdHHnmE2bNnk5eXB8C8efN4++23e7Z5++23mTt3LiJCXl4ec+bMYdu2bX3ajDWq6aPz3ypKylNWZiex8KafsxgNGDCAz3zmM9x0001ceeWVTJ48mauvvpqamhqeffZZrr76akaMGAH0Tkb+0EMPceWVV/Liiy8ydepUfvvb3/bsb/LkyWzcuJHu7m6OHj3KxRdfzOmnn05tbS1dXV0YY6ipqWHy5Mk925SXl7N69WqMMXR1dbFu3TomTZrUp81Yo5o+Ov+toqQ8cZrFaPHixUyYMIEdO3YwatQovvjFL/bY0ZcuXUpubl8RefbZZ/O1r30Nl8tFd3c3K1asYO3atQBUVFSwaNEiPvnJTwKwZMkSzjjjDK655hrOPfdccnJymDt3LpdeeimvvfYaAJdffjlr165lzpw5GGO45pprmDp1ar+OKRRaZRNYvNhq+AO8nnu6u+1kKStWJLQripI1RFplU22wvWiVzX6i898qShqgsxjFhLjb9EUkV0RWishaEXlVRD4V7zYjpbLSCv2mJqvhez5XVia7Z4qiKLElEY7czwOtxpjzgEuA+xLQZkTo/LeKomQLiTDvPAY87nzuTkB7UaFPjoqiZANxF/rGmFYAERkCPArc7ruOiCwFlgKUqSFdUZQA7G3dy9aPt+Jud1PsKmbSsElaPz9CEhKnLyJjgVXAw8aY3/v+boxZboyZaYyZOXz48ER0SVGUNGNv615qP6ylrauNooIi2rraqP2wlr2te5PdtbQiEY7c0cALwG3GmF/Hu71EUVcHVVU23LOqShO5FCXebP14K65cF4V5hYgIhXmFuHJdbP14a0z2H0m1zMbGRr70pS/FZF+JJu5x+iJyD/A5YJvX4kXGmDZ/6ycjTj9SPBm8paV980TU+aso4RNpnP496+9hU+Mm9h3ex8jBIzmv7DwmlE6gpaOFK8qviGNPU4/+xOnHXdM3xnzNGDPKGDPP6+VX4KcLcaj9pChKEOoa63hmxzM0tzczfNBwDnUc4pG3HmHr/q0Uu4qj2qdvlc0TTjiBW2+9lZ07dzJ9+nQWLlzIz3/+czZt2sTs2bO58MIL+fznP8/111/Pzp07mTVrFmAzcb/61a9ywQUXMH/+fNxud8jKm9/61reYM2cO06ZN45prronBPxQ+WVN7J5bmmIYGq+F708/aT4qiBKF6WzVlxWW4cl0c6z7G4PzBuHJdrP7HaiYNmxTVPn2rbP7oRz/q+W337t08/fTTfOMb3+DGG29k+fLl/P3vf/cbaNLS0sJnP/tZXnrpJU466SReeOGFnt/8Vd48cOAAZWVl1NbW8vrrr7Np0yb2798f1TFEQ1YI/VgXVItD7SdFUYLQ4G5g9JDRnFh8Ink5eXQc66DYVcwAGRB19M7ChQt57bXXeqpsFhQU9Px28sknk5+fD8CuXbv4xCc+AcDcuXP97stTbXPs2LEcPny4Z7m/yptFRUXs2bOHz33uc3zxi1/k8OHDfbaJN1kh9GNtjtEMXkVJLGXFZbjb3QzOH8z4kvGUDyun1FXK6cOiLz/sW2VzgFfxLe8Kl2PHju0ph1xbWxtwX/7wV3mzurqaDz/8kL/85S/89Kc/pb29nUTWQMuK2juxLsXtyeD1rv20ZIk6cRUlXlSWV7Jsva2yWewqxt3upqm9iSXTY1dl86WXXvK7zi9/+UtuuOEGCgsLycvLY5yvMAmCv8qb559/PnfddRfnn38+p556KjNnzmT37t2cfPLJ/TqWcMmKKptVVccXVPN8r6qKaVOKooRJpNE7dY11VG+rpsHdQFlxGZXllVSMir+m9Ytf/IKrrrqKESNGcNttt1FQUMD3vve9uLcbDK2yGYI4leJWFCWBVIyqSIiQ92XkyJFceumlFBYWUlRUxMqVKxPeh1iSFZo+aCluRUk1Iq6nr/Sgmn4YaEE1RUk9jDFxmxYwU+mvop4V0TuKoqQeeXl5tLa2JjRyJd0xxtDa2toz0Xo0ZI2mryhKajF06FAOHjzIoUOHkt2VtCIvL4+hQ4dGvb0KfUVRkkJOTg5aVTfxqNCPkmCOYXUaK4qSqqhNPwqClXWIdckHRVGUWKKafhR4l3WA3ndPWYdAv6m2ryhKslGhHwWhyjqEKvmg5h9FUZKFmneiIFiVzVAVONX8oyhKMlGhHwXBqmyGqsCpE7AoipJMVOhHgafKZmkp7Npl3z1TJQb7DXQCFkVRkova9KMkWFmHYL+VlR1f8VMnYFEUJVGopp9gdAIWRVGSiQr9BBPK/KMoihJP1LyTBLTip6IoyUI1fUVRlCxCNf0YoMlWiqKkCyr0/eAR4ps3Q3MzlJTAtGn+hbkn2aq0tG+yldrpFUVJRdS844NHiL/7Lrz/vhX6778P77zjP3NWk60URUknVNP3wSPE33wTCgvtq60NPvoIzjjj+MJpoerwKEomUNdYR/W2ahrcDZQVl1FZXpmUScqV/qNC3wePEHe7oajILnO57Hd/wrygAJ5/Hjo77e+TJkF+viZbKZlDXWMdy9Yvo9RVyriicTS1NbFs/TJunn1zvwS/3kiSgwp9HzwZs8XFVsMvLIT2dvvdkznrbfN/+23o6oLhw+HIEaipgVNPhTvuSPaRKEpowhG81duqKXWVUlpo08g979XbqnvewxXcnvY279nMB+4PmDp8KqcMPSVmNxIlNAmz6YvIXBFZk6j2osWTMTt2rBX6zc32fcwYu3zq1N4qmU1NMHAg5OXZ7NquLvt0MHasOnGV1MejwTe1NfXR4Osa+zquGtwNFLv6FowqdhWzec/msLb3115TRxNihPp99ew/vJ/SwlJKXaU9NxIlfiRE6IvIt4H7gPxEtNcfPBmzEyfChAk2cmfCBDjtNLu8vr7XWdvSYp8ASkth8GC44gq46CJr6lGUVMdbgx8gAwIK3rLiMtztfeuFu9vdNHc0h7W9v/Za2lsodhXjynWx9eOtgL2RNLjVGRZvEmXeeQ/4DPAHfz+KyFJgKUBZChjDg2XM3n23tfnv3Ws1/V27rLbvctnftXiaki40uBsYV9Q3CsGf4K0sr2TZ+mU9v7vb3TS1N1FSUOL3CSCQ4PZur9hVTFtXG65cV88Nxd3upqxYL554kxBN3xjzGNAV5PflxpiZxpiZw4cPT0SXoqasDN57D2prYcgQG6Z55Ig1A73zjhZPU9KHQBq8r+CtGFXBzbNvprSwlF0tuygtLOXm2TczbfS0sLb31175sHLaj7XjbnczQAbw7LvP8vS7T9PY2hjQPKTEBnXkRkhlJVx7LYjA0KF22f791uH70Udw771qz1eSQBRp4YE0+CXTlxy3bsWoCr8O1mDb+zqJpw6fypPvPAnAiEEjmDJsChv3bMTd7iZ3QC6D8gfxxp43+M6L3+HH83+sDt04IcaYxDQkMh74szFmVrD1Zs6caTZu3JiQPkXLlVdajd5j0y8vhxEjrKlnxYpk905JOMmuw+GdFu4JM2tqCistvL9hk4G29w7z9L4hXH7a5dTvr+9Z/619b1G/r56igiJcuS7aj7bT0tHC+ePP58HLHuzvPxM16RhOKiKvG2NmhlpPNf0omDbt+IlQmprUlp+VpEIdDu+0cOh9980k9EMgDT5cAm0fKMyzfn89VfOqetab9uA0hhQMoTCvEIDCvEIMhg27NkTdp/4Sr7yEVCFhIZvGmJ2htPx0QSdCUXpIhTocKTgHZ6AwT18nryDga2wwzvIkUNdYx1ef+yobP9rIm3vfzMhwUq29EwU6EYrSQywEbl0dVFXB4sX23bfAUyjKyqxJx5skh5GF6ySeNW4WhzoP0dbVhjGGtq42DnUeYta4xOuHHg1/3+F9DCscRltXG7Uf1rK3dW9GhZOq0I+Sigp7fa5YYd9V4Gcp/RW4HvNQU1Nf81Akgj8FHz0ryytpam+iqa2JbtNtE7Lam6gs79unm2bexKlDTwXouUmcOvRUbpp5U8L77DFJjRg0go5jHRTmFfbkEWRSOKkKfUXpD/0VuLEwD6Xgo2egME9fm3jFqArumH8HiyYuYsaYGSyauIg75t+RFNu5xyTlCSdt62qjIKeAfYf3+b1hpSvqyFWU/uARuN7RO0uWhC9wY1WmNYo5OCOJUOlvNEtjayMPbHyAjmMdx23fX2dyrCgrLqOprYlRg0cxe9xstn28jX2H9zFi0IiMceJCAkM2wyUVQjZjEYGX7Cg+JU2oqvIfClZaan+LE4FCKv0Jt0jW9bdN+9F21vzDlt2ae9JcXLmukNsng2iOM5UIN2RTzTs+xMLEGot9KFlCIuzxfhzF4dbdgfBr9ATaZvuB7RQVFFFUUMT2A9t7tn9g4wNU1VSx+InFVNVUJT0TN1yTVLqTteadQJp4P0Kee4jFPpQsYuBAWL3apnnPmhVbe3yAPIKGC1oYN75vG4EiVMKt0RNoG3e7m6KCop7PAO1H2/n7B3/n0omXplQsfKqYmuJJVgr9YPk0sTCx6mxaSlh4D8TLL+/NpI0lATSQsn800DTK3ZM0BYHr5nhs3eGs67tN57FOmtqb2NWyi/ycfEYPGQ3A5sbNnFB4gt8a/f7MS+mWHZvKZKV5J1jARCxCnlMwbFpJRRKR2BUgj6ByT0lYIZUQfvil7zbvN71Pzc4aBuUOwmA40nUEd7ubdw+8y4G2A0wbNa1vt/w8PYRb818Jn6wU+sHyaSI1sfrLq0nBsGklFQmV2BVO0laodQJoIBWjp4Vtv47G1l0xqoKxRWMpKigiPzef8cXjOWXoKeTl5LH70G4WTFiAK9fVt1t+nh6i8ScowclK845nSkTvgAmPJh4sAs/XDzBkCPz+973TJXZ09JqJ+hPFp2QJwQZiODV9wlmnstIug77F2JYsich+HY2tu/NYJxedehEDpFe37Dbd7GrZxZdmfimsCp/R+BOU4GSM0I8kRDLIdQD4D3n2vb7eeQeefdZW1xw1ys6jW19vp1Osrj4+S9ejkGkIp9JDsIEYTjRAOOv0N4+gHwTzBXieHrxt9UumLznuxhKNP0EJTkbE6UdTWTbSOPobb4Q33rBTIRYXQ2srvP++1fZPPtmu09ZmZ9A65ZS+JZZD9U9j+rOYQCd/8WKrXQzwssB2d/et3x3OOoGaTYBz1GOPP9Z9jF0tu9h/ZD95OXncft7tXDXlqoj2EapEszp3syxOPxp/WCS1c+rqYNUqMMZOfN7WZgV+fr6dNcuDy2UnVPF12Pr2r7MTtm+Hf/kXezO57TaN6Vd8CCcaIMqIgUQ5RytGVVjhvK+e/Uf2M3zQcKYMm8KT7zwZdlv+/AmXn3Y5T771EfGJAAAePUlEQVTzZMKdu3WNdSmVVxAtGSH0411ZtroaTjjBhlGL2FmyCgutLT8nx94EjLHXW17e8Q5b7/7t3WunWvQ8YL3xBuzYYW8EyarMqySJYFl84UQDRBkxkEjn6KoPVuHKdVGQU4AgFLmKIm6rYlQFVfOqWHHFCqrmVVG/vz7hzt1MiiLKCKEf7xDJhgY7cUp7e6+ALy21gnrGjF4N3xi4/fbjnxq8+7d1q11fBEpK7D6GDLHLPWhMf5YQ7BE1nCJqURZaC7fWfX+pa6xj1furMBiKCopo62pj/a71tB9t71dbieq/N5kURZQRjtxQjtn+4gmymDPHCme3GwYNgkWLYPJk2Ly5V4jX18Npp/W97rz719xszUIdHTB9OmzbZk1E3jctjenPEkJl8YVTRC2KQms9ztGWzp4B7S7Op2zSjIj2E4rqbdWcUHgCACLSMzvW5sbNLJq4KOr9JsO5m0lRRBmh6ce7sqznKTo/H+bOta/TT4fvftf+VlQEZ5xh2/Nnk/fun8dENHu2jfopL4dDh+y+NaY/y0hSFl9leSVNe96naUMN3e1HaCrKo6mzhcq/fRhTZ1KDu4GyojJ2unfy1r63+KDpAw53HuZA24F+lSmOJlmsv4Q7KUw6kBGaPkSl8ES070BRbzfeaJ2ynqie8vK+T+i+/fNo/QUFVsgXFNhonxNPtDcsjenPIuL9iBqAilEV3Nwwlur8fTS4OimjmCX5M6gYVADV1dSNsFr65j2bae5opqSghGmjp0UcIVOQU8D6/esZMXAELZ0tHOk8wuHOw8w/eX6/5+UNFO4Zr6ikyvLKsPIK0oGMCNlMFh5/29Ch1rHb3m5fs2ZZh+20af7DMDVEU+kh2GCI50AJEO5Zt7eOZRcXcfTYUer31zOAAXSbbj4x8hPkDMiJqCDajU/dyOqdqykqKMKV66L9aDstHS2cP/58HrzswdgchxfxLo2c6jWAwg3ZzBhNP5F4rsXHH7eO3bY2Wyix0Josqa2119JJJ/lPlIznU4mSZgQaDOFk2/aHANnA1aObKXWdxJt736Qwt5DCvELautrYfWg3Z4w8w29BtEB0Hutk7klz2X5gO+52N8WuYqaNmkbnsc7+998P3s5WCF7ELRoypQJnUJu+iAwTkWUi8hMRGem1/Pvx71pq4h1lB71+hAMHbPSOMbB7N0yZEt86WkqGE+9ibAHCPRtOKunRkj21cVy5rh6hHYnjsqy4DFeui3nj53FF+RXMGz8PV64rbnbwZET1pCOhHLl/AHYADcAqEXFyTzk/rr1KYbyvxZISG8Uzbpx1xra0WCftiBFw6ql9t9MwTCUi4p18EiD6oezkaT0Cvv1oO2Br33tuBJEI7EQ7XDPJ2RpPQpl3XMaYBwFEZAvwmIjMByTuPUsRfM2qmzfDyJFQUwN79ljf27Bh9gYwd65VmAYOtMv91dFSlLAIVowtVvgxLVU2wrL1yxgzeAz1++vpONpBt+nm1KGnRuy4DLe+TqzIJGdrPAkl9EVEphtj3jDGvCwidwB/BQYloG9Jx59Z9e234c03ewut5eVBY6PN2C0t7Q28SEJQhpJJJDOyxxHUR7qO9ETvTDxhYlSOy0TawRN9k0lXgkbviEgFcDfwT8aYRmfZPwP3GGNOiEeHUil6x9+c1Y89ZjX8U06xmbXt7dasM28ePPBA73qRBF5oNI/ilyADI9UjSZTEE270TsQhmyIyDPhXY8xPou1cMJIl9P1dX3fffXxUmydiZ/Roq3wVF9tEra6ukIUNA7YbaYVQJbuJd2iikp7EPGRTRM4BvgwsBB7rR99SjkDRcYMGHW+bLyiwr/JyW0LB7bZ2/unTo2tbJ1HPEvrxOFfXWEf16gdo2LqBMrehsTiX0lNOp7Q0PqGJSuJIxhNbqJBNl4gsFpHXgWXAZGCCMeYrkTQiIreKyDrnNasf/Y0LgaLjjDk+qm34cCv0V6+2NXPy8qx5Z/fu6DLY4x2koaQAwapphtq0sY5lz9xG04YaxrXn0VSUz6pj79L+xqs2A9BBQxPTj2RV7gwVsvk+MAW42hhzHvChMaYtkgZEZBJwCXAu8E/AfdF0NJ4EErydncdHtf34xzYGv6jImnQGDrT2/AkToguh1knUs4B+xNxXb6umtGEfpQVF7HN186bsw53TxVOD99C49bWe9WIRmpgp9eLThWRV7gxl3rkHK6jHi8hviK5A21zgeWOdB/8QkVwRKTLGtESxr7gQas5c36fwjg646KLjJyyKRjtPUpCGEktCmW78VdNsb4cnnghp7mlwNzDO3UFjUQ7r2Y2LHE6kiPcGNLG6613mHtqDK9cVOjQxRB+9/QTeWqf6CeJHsip3BhXixpj/MsacAdwLXAN8UkTuFJGpEbRxAtDs9b3VWdaDiCwVkY0isnH//v0R7Do2RDoXRSy183hXCFXiTDimG98Bs3cvrFljS6uGMPeUFZfhLi5g27FGXORQSB555DDxWDFFeYN5ZfcrlBaWBhfOYfQxk+rFpwvJSiYLS3M3xqw2xlwLnArswmbqhksTMMTrewlwwGf/y40xM40xM4cPHx7BrmNDpII3ygmLgrYf7tSNSooRjunGd8Bs2mSXT58e0txTWV5JU9kI9nUfpuCooY0u2o91cNbhEi4qv4wZo2dQNa8quDYeRh+1hEHiSUaJaAhD6IvIJ0XEk4E7FthijIkkVmUt8P+cfZ0MdKWSacdDJIJXtXOlh1CeeI9ZpaXFZvXV1Vn74Ny5NrvP3zZeVIyq4OZL7mDEmFP5OLeLwo5jzMkZz8hzLsRdHGYdmzCiBbSEQeLxN/9vIsxpQW36InI98BVgPtAC5APLROR/jDG/D6cBY0y9iLwkImuBHOCm/nU5NdBKmRlCfzPjgjmEvGOBKyp6HTazZtkQsL17e6diy8+3c2/6oWJUBfdetaJPbH5TJCUGwijpEKsSBr4hiFOHT6V+f70mkQUgGZU7Q2XkrgcuNMYc8Vo2GFhljIlL6GUqZeQGQ7NoM4BoM+O8T35BAXz4oU3R9t1HdfXxwrapyYaF7doFO3bYCZLBVuw75RQbHhag7YAx3aEGY5jH2d+Ycd+ksR0HdrBh9wZmj5vNKUNP0SSyOBOTjFwRedEYM9/P8jXGmLn97KNf0kHoaxZthnDTTda+7pn2bNIkq3GXllobnz/8nfz334exY+1+vIWuv4lK9uyBV1+1SR6trTB4sE3vLi+3N5BgbYfbH3+DMQFaSlVNVZ+5a2t21tDc1kxJYQnzxs8D6Pm9al5VTNtWYpiRKyIjjDH7vL8DA/vZv7RGs2gzgLo6+Nvf7LRnRUW2tkZtrTW9BIu99XfyJ0zwL6x9zSqeqJ2iIpv5V1xs7fvl5da+H03cb7iDMQH2SN8QRHe7m6KCoj6+AnUOJ59QQv8nwIsicje2pv5JwNeBO+LdsVTGX9i1ZtGmGdXVtjQq2EkQPNOebd4MixbZz/6040hOvm8ShnfUzrZt9kbjctnPo0ZFF/fr1Z86GqlmGw0lzZS5obIxsfbzsuKyPpp+sau4R9P3oM7h5BMqTv9vwFLgHOBrwHTgWmPMwwnoW8qiWbQZQEODncS4vd0KX8+0ZwcOWGEdKLY9Pz/8k+8b5uUdtTNpkm3bGGhujj7u1xmMdTSyjPU00ca4jnzeLT7GtY9fy5V/ujJh2bW+IYhjBo+hpbOFsUPGJjQkUQlOqOid7wFLsJOmfMMYk1GF1oLhT8kDu2zzZvjgA5g61freNIs2DfGYXmbP7q2cl58PCxb0xu/6M5t0dvbOlRlOCrW3WcVTqxvsTDxz5vRq/57JGCI1wThPE9Wu7ZS6CijtgL2dzdSPBDEDaepoSlh2rW89+9OGnUblpMo+0Tta3z75hHLkvoqtmVMC/NEY8//i3aFUcOT684299561AkyYYJft2AFvvQUnn2wVRo3eSTNCOUD9OWG7u63G/vWvR+cUjVcEQF0di6uvY5zbMKC4hJphrbQV5ODKddHS0cIV5VeoAzULiJUjt9UY0wnsE5GwyzCnO7/4BWzf3hvUUV4OnuoQZ55p3087zVbcjDTYQkkRPKYXb+HtrWmXlcE778BHH/VOnDBmjD3x0TpFQ7XZj2MpO9gr2N3bnqAod1DP3LagDlSll6wR5OFSVwerVvUN6li/3r4P9IlZUudtmhNMeE+dCr//vR0ERUXW7t7QENzmHk68fJzCJr2TqzwRM0YM00fb5PlYVeHU2brSn1BlGKaIyMMi8ievzw+LSMY6cj1BHSK9QR0uFxw+bMOovfH139XVWa1/8WL7Hk19fSVORHpy6uutvb+kxCZOlZTY7/X1gfcfrKhZP2rqh4N3Sn+pqxSDYcqwKYwYNCIiB2qg8srJqv2uxJ5QNv3zA/1mjFkdjw4lwqYfTOFavNhOjLJhgxX2LpfV8vfssbZ7j03fNycnP99OpOL9uyZspQjR2NKD2fT9zYvpb0Jlz/eqqtC/x5hQWrm/34GA0zBWb6vuE44JmmiVasTEph8vwZ5MAk2N6Ln+PUEdc+b0LYty2WU2gdM7+96Y3ve//tUmWO7ZA2edZYMzQBO2UoJosunCqFfTh1Dx+wlO7ghW0yVQ7fyBeQN7yitD32kYk1X7XYk90UyKktaEqjLrqYKbn29DqufOtROf33RT30qcI0facM2ODvtU0Nlp59Tds8cmdu7dqzb/lCGaOSljPclCCiV3BKqdv2HXhoDllbUKZ+aQdUI/1PUfbtlkz362bbMmoEGDrA/g2DH73fOUoAlbKUA0AjfWkyzEaBKGWExpGKh2viABBXuyar8rsSfronfCeWr3Derw+AC9fQCe/bjdNrhj2DDYudOaewoKYN8+TdhKGaKdk9IzCDw2Pc/joGe5r3Po8suto9dfOGYMwjVjNaWhb7kEsMJ91rhZNLXb5DHf8sq+iVeaaJW+BHXkJoN4O3Ij9ekFWv/yy+HJJ208vzFWy29qsjeAI0dgxAi4996EFzpUAhHNnx9ssEDCS636VrGE6JypviWQvR22gIZlpikxKa2cDJIdveNLsKCLykqbyLVqlQ3znDbNmnYCVbbVcsxpRrCT7/vZ+3ucsvUWP7GYcUXjGCC9Vtnuxj3s2vYqKxqmR6RJaMx95hGz0sqZSCQJlcGCLioq4MEH+95EBgywSVx33933GtRyzGlIqIibBJdaPc4ss3cv7lfWUJZf5D8ULQjJmLFJSQ2yzpEbKeH4AD1RPV//em8Sl2/+TTQBJEqSCXbykxCNc5wzdesmmgqhsnB6n1C0R6t/yLyV85j4PxOZt3Iej771aNz6pKQfKvRD4C/o4r33bEimb3KnR5vv6LBzZaxZY23+v/hFSkXsKeESLOImRtE4kXDcRNruDm7OnUsFvROsP1q8m28ffY7mtmZGDxpNc1sz31717ZQU/LGIRFIiJytt+pHibb4Jlnl7993+s3kPHoQ777SOX7XppxnBHEDJ9sz78TnM6/oVzXlHKRk/qWeZZyKTmutrEte3EARzJqvZKTrUph9DfEuie6Yyhb62+bIyePZZK+w9EzGJWCdvfX18CiwqMcRXiE+d2jcE01eoJ2AKwqD4CUXdPfgQo084tc9qRQVF7D60OwkdDIx3ghj0zf5VoR9f1LwTIcFs85WVduIlzyRMbW12cqRp03odv56M3qoqFfgphW9BtHfegW9/G959Ny4F0mKCnwSysaNPoyW3G4DWzlZ2Nu+kfl89Xce6Usp8EihBTMs6xB8V+hESzDZfUQELF1rtvqXFavtz5ljNX233KY5vfY6PPrJJF7t3+6/XkSr4aBJfueBWWjpb2HNoDw3NDRzuOIzBMHnY5JSqiqllHZKHCv0ICeW/u+kmW6vHU7cnPz/u/j0lFvg+wnlSrT13+MZGO0/mQw+ldN3sq6ZcxU8X/JSOYx10dncyqGAQCyYs4OxxZ1PqKqV6W2rctLSsQ/JQR24UJHGuDCVe+DpFa2rsxCklJXbqtPXr7SNccbG116W4F95vIpfpZlfLLlZc4ac0dBDilcilCWKxRR25URCusA7lv0u2f0+JAl+n6JgxdiBMmWKr54lYR83kyWmRWReovk6k5pNY1fvxhyaIJQc17zjEeWIjJdXxdYqedhr89KcwcaK17xcXWweNZ6KEFM+s62M+adxDU82zNL34NJU1jREN6kBlmFPFTKRETlZo+uFo8FomQfH7iHbVVfY9kglVUoCeqpirH6Dhtb9TlnsCSwovpKKpIOxSDYBOnpKBJETTF5GBIvKGiJQnoj1vwtXgtUyCEhBv7/2ePTYZ4+mnrXM3hR8FK0ZVULV1JCuOXkpV4SIqBoyOOApJo2wyj7gLfRE5C1gNjI53W/4INVOWBy2TkCVEM3u9x/TT2Ql//7tdduGFNksv1W2A/dRmNMom80iEpl8AfBrYloC2jiPcMZ+EUipKIqmrs/G0lZVWU8/Li8xxU1Fh7fmXXgqLFsHoyLXmpNBPbea4ej+FpVoqIc2Ju03fGPMygIgEXEdElgJLAcpirFqHO791DCY2UlIVj41v+3YYOtQu27ABZs/uFdrhnOgET24eE6KdNcwLjbLJLOIi9EXkB8D5ztcLjTHHgq1vjFkOLAcbpx/LvkQy5v358TTmPgPw2Pg6O23ClUcB2bbNZtCFEtqeQbBpE7z1FsyY0RvFk+o2QNVmFB/iIvSNMd+Px36joT9j3nu2qwjnqFBSCY+GXlxsCyIVFtraGG53aKHtPQjOOcfWy66psTcLzzRpqT4RsiaOKF5kRchmtGNewzgzBI+Nb9IkqK21y4zprZERTGj7DoLzz4c33oBXX4UrrkgbrVmzXxUPCUvOMsbMM8YkxZkbLRrGmSF4vPT5+TBrll128CBMnx76sc13EIwaBRddZLdNk1KpnqzapramPlm1qVJ8TUksmpEbBA3jzBC8s227umz0TXW1neA4lNDOgEGgWbWKN1lh3omWGAQ+KKlCtDa+DBgEmlWreKOafhD8zFGhTtxsIwMGgWbVKt6oph8CDXzIMgLF6KbxIKgsr2TZevu04j0f7ZLp6fO0osQOraevKB68wzN9Z6+HtE7Y0OidzCfcevoq9BXFg+9EKmC/d3TAkSP+bwZpJPiVzEYnUVGUSAlUZuHJJ218fqolbGi6uBIF6shVFA+BwjM90yR6k+yEDZ31R4kSFfqK4iFQqdVZs1IvVj/cmuGK4oMKfUXxECg886abUq/utqaLK1GiNn1F8SZQeGaqVaoMt2a4ovigQl9RwiHVYvUzIFNYSQ4q9JXUIxlRKRG2mfS4d62Tr0SJxukrqUWwBKlYCTRfAT91qg3LDLNNT9XKUldpnwxXnUZQSSbhxumrI1dJLeIdleIv1PGHP4SjR8NuU6tWKumMmneU1CLe89D6mxmnqwt274bTTgurzbSqWqkJXIoPqukrqUW869f7C3UcPhz27w+7zbSpWqkJXIofVOgrqUWgBKlYxcT7u6mMGwd5eWG3WVleSVN7E01tTXSbbprammhqb6KyPIlx+/7QBC7FDyr0ldQi3vXr/d1UcnLg9tvDbrNiVAU3z76Z0sJSdrXsorSwNDWduF5PNXU0UkUNi0tWU+V+XKdKzGI0ekfJPmJp505lm7lTNbSutINlrKcUF8XtBrdLaDrj9NS8USlRo1U2FSUQsUq08g4v9baZe54Skn1DcBK4ql3bKXUVUNoBtHVQOn0OuPKp3latQj8LUfOOokRLMJt5KjhRHVNZQ2EnxS2d4CqEOXNg5MjUjTZS4o5q+ooSLcHCS/2FhkLia/BXVFB28Aqa2pooLeyt05OS0UZKQlBNX0kd6uqsHXrxYvue6qGFwcJLU6gKZtpEGykJQYW+khqkgjkkUoKFl8Y73yAC0ibaSEkIat5RUoNUMYdEQqiiZylUBbNiVIUKeQVQoa+kCvEuvxAvAkUCaRVMJUVRoa+kBpk4KUiq1eBXFNSmr6QK8S6/oCgKkABNX0Q+B3wTOAbUAV8yxnTHu10lzQhlDkl2opOiZAhxLcMgIi5gKzDVGHNYRP4C/NEY89dA22gZBuU4EjGxiqKkOakyiUonMMcYc9j5LsBR35VEZKmIbBSRjft9S9wqilaLVJSYEVehb4zpNsbsARCRrwIlwHN+1ltujJlpjJk5fPjweHZJSUdSKNFJUdKduAh9EfmBiNQ4rxwRuRNYCHzapFpZTyX1SaFEJ0VJd+Ii9I0x3zfGzDPGzAMeAIqAK7zMPIoSPhrZoygxI67mHRGZDtwATAFedDT/T8ezTSUDiffEKoqSRcQ1ZNMY8waaC6DEAk10UpSYoAJZURQli1ChryiKkkWo0FcURckiVOgriqJkEVplM4loORlFURKNavpJIh0nilIUJf1RoZ8ktJyMoijJQIV+ktByMoqiJAMV+klCy8koipIMVOgnCS0noyhKMlChnyS0nIyiKMlAQzaTiJaTURQl0aimryiKkkWo0FcURckiVOgriqJkEWrTVzITrXGhKH5RTV/JPLTGhaIERIW+knlojQtFCYgKfSXz0BoXihIQFfpK5qE1LhQlICr0lcxDa1woSkBU6CuZh9a4UJSAaMimkplojQtF8Ytq+oqiKFmECn1FUZQsQoW+oihKFqFCX1EUJYtQoa8oipJFxF3oi8iVIvKq8/pqvNtTFEVRAhPXkE0RyQH+GzgTOAJsFZGHjTEfx7NdRVEUxT9x1fSNMceAScaYFmAosBdoimebiqIoSmDinpxljDkqIpXAfcBmoBBo9V5HRJYCS52vrSKy3Wc3w4B0fzrIhGMAPY5UIhOOATLjOFLhGE4KZyUxxsS8ZRH5AXC+8/VCY8wxERkA/Bp43Rhzf4T722iMmRnrfiaSTDgG0ONIJTLhGCAzjiOdjiEumr4x5vsAIlIEvCgiC40xnSJyGDgQjzYVRVGU0MTVvGOMaRGRPwNrRaQTeBX4SzzbVBRFUQKTCJv+A8AD/dzN8lj0JclkwjGAHkcqkQnHAJlxHGlzDHGx6SuKoiipiWbkKoqiZBEq9BVFUbKIlBf6mVDGQUQ+JyKviEitiDzohK+mJSIyUETeEJHyZPclGkTkVhFZ57xmJbs/0SIic0VkTbL7ES0ikisiK0VkrXNtfyrZfYoGERkgIr8SkZedY/lEsvsUipQWPl5lHBYAc4B/E5Fhye1VZIiIC7gTmG+MmQOUApcmt1fRISJnAauB0cnuSzSIyCTgEuBc4J+wCYNph4h8G9v3/GT3pR98Hmg1xpyHPSdpeS6ATwE5xphzge8BP05yf0KS0kI/Q8o4dAJzjDGHne8CHE1if/pDAfBpYFuyOxIlc4HnjeUfQK6TS5JuvAd8Jtmd6CePAbc5n7uT2ZH+YIx5gt5qAuOxYekpTUoLfehTxmEz0IIt45A2GGO6jTF7ABzzVAnwXHJ7FR3GmJeNMbuS3Y9+cALQ7PW91VmWVhhjHgO6kt2P/mCMaTXGuEVkCPAocHuy+xQtjoz6LXA3aZB8mpJCX0R+ICI1zivHGFMNjAMageuS3L2w8D0GEbkTWAh82qRRnKzvcSS7P/2kCRji9b2ENLhIMxURGQusAh42xvw+2f3pD8aYLwCnAbeJSHGy+xOMuCdnRUMmlHHwHAOAiCzHmnSuMMak1aOs93FkAGuBe4E7ReRkoMsxHSoJRkRGAy8AXzPGrEp2f6JFRP4FGGOMuRNbPv6Q856ypKSm78G5ID1lHNZi7eNpVcZBRKYDNwBTsDewGhH5dJK7lZUYY+qBl5yx9BBwU5K7lM3cijWtfdfrSTKtTLcOjwFnOZFUz2BvYiltetOMXEVRlCwipTV9RVEUJbao0FcURckiVOgriqJkESr0FUVRsggV+oqiKFmECn0laxGReSKyzwkXfElENopIlfPbQmdZjVMs7ws+294iIntEZKCf/S4XkRsTdBiKEhEpmZylKAnkRWPM1QAiUgC8KyJ/w6bULzDG7BGRQdhckR3GmLXOdp/H5pBcA/zG2X4EsBI4HdiU2MNQlPBQTV9ReinGXhOLgXs8NZOcYnnzgVqwTwjYomcPAl/22n4I8H3gD4nrsqJEhgp9JduZ7zHvAA8D38CWjm7wXskY0+xUfQWbYf0bY8x24IiIzHbWec8Y81oC+64oEaPmHSXb6THveBCR+cBJPstmYCtb7gIWAcUicgMwEKvtr09MdxWlf6imryjH82vg6yIyEkBEBgPLgWHAP2O1/E8ZY67ETsiy0LHnK0rKo0JfUXwwxrwO3AE8IyIvAy8C9xtjXsKadv7ote4RbNGtG5LRV0WJFC24piiKkkWopq8oipJFqNBXFEXJIlToK4qiZBEq9BVFUbIIFfqKoihZhAp9RVGULEKFvqIoShbx/wMYJOVfGALcHQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#标准化之后效果反而没有那么好\n",
    "plot(pca.transform(iris_x_normalized), iris_y,\"Iris: Data projected onto first two PCA components\",\"PCA1\",\"PCA2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ✅ LDA：\n",
    "LDA，即**线性判别分析（Linear Discriminant Analysis）**，它是一个有监督的算法（哦对了, PCA是无监督的），一般是用于分类流水线的预处理步骤。与PCA类似，LDA也是提取出一个新的坐标轴，将原始的高维数据投影到低维空间去，而区别在于LDA不会去专注数据之间的方差大小，而是直接优化低维空间，以获得最佳的类别可分性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# LDA的使用\n",
    "# 导入相关库\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "# 实例化LDA模块\n",
    "lda = LinearDiscriminantAnalysis(n_components=2)\n",
    "# 训练数据\n",
    "x_lda_iris = lda.fit_transform(iris_x, iris_y)\n",
    "# 可视化\n",
    "plot(x_lda_iris, iris_y, \"LDA Projection\", \"LDA1\", \"LDA2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 特征学习\n",
    "## 数据的参数假设\n",
    "参数假设指的是算法对数据形状的基本假设。比如上一章的PCA，我们是假设：\n",
    "原始数据的形状可以被（特征值）分解，并且可以用单个线性变换（矩阵计算）表示。\n",
    "而特征学习算法，就是要去除这个“假设”来解决问题，因为这算法**不会依赖数据的形状**，而是依赖于**随机学习（Stochastic Learning）**，指的是这些算法并不是每次输出相同的结果，而是一次次按轮（epoch）去检查数据点以找到要提取的最佳特征，并且可以拟合出一个最优的解决方法。\n",
    "而在特征学习领域，有两种方法是比较常用的，也是下面来讲解的内容：受限玻尔兹曼机（RBM）和词嵌入。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " 受限玻尔兹曼机（RBM）\n",
    "RBM是一种简单的深度学习架构，是一组无监督的特征学习算法，根据数据的概率模型学习一定数量的新特征，往往使用RBM之后去用线性模型（线性回归、逻辑回归、感知机等）的效果极佳。\n",
    "从概念上说，RBM是一个浅层（2层）的神经网络，属于深度信念网络（DBN，deep belief network）算法的一种。它也是一种无监督算法，可以学习到的 特征数量只受限于计算能力，它可能学习到比原始要少或者多的特征，具体要学习的特征数量取决于要解决的问题。\n",
    "\n",
    "“受限”的说法是因为它只允许层与层之间的连接（层间连接），而不允许同一层内的节点连接（层内连接）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "“受限”的说法是因为它只允许层与层之间的连接（层间连接），而不允许同一层内的节点连接（层内连接）。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
